1 /**
2 * WinPR: Windows Portable Runtime
3 * Microsoft Remote Procedure Call (MSRPC)
4 *
5 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <winpr/crt.h>
25 #include <winpr/rpc.h>
26 #include <winpr/crypto.h>
27
28 #if !defined(_WIN32) || defined(_UWP)
29
30 #include "../log.h"
31 #define TAG WINPR_TAG("rpc")
32
RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding,RPC_BINDING_HANDLE * DestinationBinding)33 RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding, RPC_BINDING_HANDLE* DestinationBinding)
34 {
35 WLog_ERR(TAG, "Not implemented");
36 return 0;
37 }
38
RpcBindingFree(RPC_BINDING_HANDLE * Binding)39 RPC_STATUS RpcBindingFree(RPC_BINDING_HANDLE* Binding)
40 {
41 WLog_ERR(TAG, "Not implemented");
42 return 0;
43 }
44
RpcBindingSetOption(RPC_BINDING_HANDLE hBinding,unsigned long option,ULONG_PTR optionValue)45 RPC_STATUS RpcBindingSetOption(RPC_BINDING_HANDLE hBinding, unsigned long option,
46 ULONG_PTR optionValue)
47 {
48 WLog_ERR(TAG, "Not implemented");
49 return 0;
50 }
51
RpcBindingInqOption(RPC_BINDING_HANDLE hBinding,unsigned long option,ULONG_PTR * pOptionValue)52 RPC_STATUS RpcBindingInqOption(RPC_BINDING_HANDLE hBinding, unsigned long option,
53 ULONG_PTR* pOptionValue)
54 {
55 WLog_ERR(TAG, "Not implemented");
56 return 0;
57 }
58
RpcBindingFromStringBindingA(RPC_CSTR StringBinding,RPC_BINDING_HANDLE * Binding)59 RPC_STATUS RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE* Binding)
60 {
61 WLog_ERR(TAG, "Not implemented");
62 return 0;
63 }
64
RpcBindingFromStringBindingW(RPC_WSTR StringBinding,RPC_BINDING_HANDLE * Binding)65 RPC_STATUS RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE* Binding)
66 {
67 WLog_ERR(TAG, "Not implemented");
68 return 0;
69 }
70
RpcSsGetContextBinding(void * ContextHandle,RPC_BINDING_HANDLE * Binding)71 RPC_STATUS RpcSsGetContextBinding(void* ContextHandle, RPC_BINDING_HANDLE* Binding)
72 {
73 WLog_ERR(TAG, "Not implemented");
74 return 0;
75 }
76
RpcBindingInqObject(RPC_BINDING_HANDLE Binding,UUID * ObjectUuid)77 RPC_STATUS RpcBindingInqObject(RPC_BINDING_HANDLE Binding, UUID* ObjectUuid)
78 {
79 WLog_ERR(TAG, "Not implemented");
80 return 0;
81 }
82
RpcBindingReset(RPC_BINDING_HANDLE Binding)83 RPC_STATUS RpcBindingReset(RPC_BINDING_HANDLE Binding)
84 {
85 WLog_ERR(TAG, "Not implemented");
86 return 0;
87 }
88
RpcBindingSetObject(RPC_BINDING_HANDLE Binding,UUID * ObjectUuid)89 RPC_STATUS RpcBindingSetObject(RPC_BINDING_HANDLE Binding, UUID* ObjectUuid)
90 {
91 WLog_ERR(TAG, "Not implemented");
92 return 0;
93 }
94
RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc,unsigned long * AuthnLevel)95 RPC_STATUS RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc, unsigned long* AuthnLevel)
96 {
97 WLog_ERR(TAG, "Not implemented");
98 return 0;
99 }
100
RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding,RPC_CSTR * StringBinding)101 RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding, RPC_CSTR* StringBinding)
102 {
103 WLog_ERR(TAG, "Not implemented");
104 return 0;
105 }
106
RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding,RPC_WSTR * StringBinding)107 RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding, RPC_WSTR* StringBinding)
108 {
109 WLog_ERR(TAG, "Not implemented");
110 return 0;
111 }
112
RpcBindingVectorFree(RPC_BINDING_VECTOR ** BindingVector)113 RPC_STATUS RpcBindingVectorFree(RPC_BINDING_VECTOR** BindingVector)
114 {
115 WLog_ERR(TAG, "Not implemented");
116 return 0;
117 }
118
RpcStringBindingComposeA(RPC_CSTR ObjUuid,RPC_CSTR Protseq,RPC_CSTR NetworkAddr,RPC_CSTR Endpoint,RPC_CSTR Options,RPC_CSTR * StringBinding)119 RPC_STATUS RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr,
120 RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR* StringBinding)
121 {
122 WLog_ERR(TAG, "Not implemented");
123 return 0;
124 }
125
RpcStringBindingComposeW(RPC_WSTR ObjUuid,RPC_WSTR Protseq,RPC_WSTR NetworkAddr,RPC_WSTR Endpoint,RPC_WSTR Options,RPC_WSTR * StringBinding)126 RPC_STATUS RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr,
127 RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR* StringBinding)
128 {
129 WLog_ERR(TAG, "Not implemented");
130 return 0;
131 }
132
RpcStringBindingParseA(RPC_CSTR StringBinding,RPC_CSTR * ObjUuid,RPC_CSTR * Protseq,RPC_CSTR * NetworkAddr,RPC_CSTR * Endpoint,RPC_CSTR * NetworkOptions)133 RPC_STATUS RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR* ObjUuid, RPC_CSTR* Protseq,
134 RPC_CSTR* NetworkAddr, RPC_CSTR* Endpoint,
135 RPC_CSTR* NetworkOptions)
136 {
137 WLog_ERR(TAG, "Not implemented");
138 return 0;
139 }
140
RpcStringBindingParseW(RPC_WSTR StringBinding,RPC_WSTR * ObjUuid,RPC_WSTR * Protseq,RPC_WSTR * NetworkAddr,RPC_WSTR * Endpoint,RPC_WSTR * NetworkOptions)141 RPC_STATUS RpcStringBindingParseW(RPC_WSTR StringBinding, RPC_WSTR* ObjUuid, RPC_WSTR* Protseq,
142 RPC_WSTR* NetworkAddr, RPC_WSTR* Endpoint,
143 RPC_WSTR* NetworkOptions)
144 {
145 WLog_ERR(TAG, "Not implemented");
146 return 0;
147 }
148
RpcStringFreeA(RPC_CSTR * String)149 RPC_STATUS RpcStringFreeA(RPC_CSTR* String)
150 {
151 if (String)
152 free(*String);
153
154 return RPC_S_OK;
155 }
156
RpcStringFreeW(RPC_WSTR * String)157 RPC_STATUS RpcStringFreeW(RPC_WSTR* String)
158 {
159 if (String)
160 free(*String);
161
162 return RPC_S_OK;
163 }
164
RpcIfInqId(RPC_IF_HANDLE RpcIfHandle,RPC_IF_ID * RpcIfId)165 RPC_STATUS RpcIfInqId(RPC_IF_HANDLE RpcIfHandle, RPC_IF_ID* RpcIfId)
166 {
167 WLog_ERR(TAG, "Not implemented");
168 return 0;
169 }
170
RpcNetworkIsProtseqValidA(RPC_CSTR Protseq)171 RPC_STATUS RpcNetworkIsProtseqValidA(RPC_CSTR Protseq)
172 {
173 WLog_ERR(TAG, "Not implemented");
174 return 0;
175 }
176
RpcNetworkIsProtseqValidW(RPC_WSTR Protseq)177 RPC_STATUS RpcNetworkIsProtseqValidW(RPC_WSTR Protseq)
178 {
179 WLog_ERR(TAG, "Not implemented");
180 return 0;
181 }
182
RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding,unsigned int * Timeout)183 RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding, unsigned int* Timeout)
184 {
185 WLog_ERR(TAG, "Not implemented");
186 return 0;
187 }
188
RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding,unsigned int Timeout)189 RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding, unsigned int Timeout)
190 {
191 WLog_ERR(TAG, "Not implemented");
192 return 0;
193 }
194
RpcMgmtSetCancelTimeout(long Timeout)195 RPC_STATUS RpcMgmtSetCancelTimeout(long Timeout)
196 {
197 WLog_ERR(TAG, "Not implemented");
198 return 0;
199 }
200
RpcNetworkInqProtseqsA(RPC_PROTSEQ_VECTORA ** ProtseqVector)201 RPC_STATUS RpcNetworkInqProtseqsA(RPC_PROTSEQ_VECTORA** ProtseqVector)
202 {
203 WLog_ERR(TAG, "Not implemented");
204 return 0;
205 }
206
RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW ** ProtseqVector)207 RPC_STATUS RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW** ProtseqVector)
208 {
209 WLog_ERR(TAG, "Not implemented");
210 return 0;
211 }
212
RpcObjectInqType(UUID * ObjUuid,UUID * TypeUuid)213 RPC_STATUS RpcObjectInqType(UUID* ObjUuid, UUID* TypeUuid)
214 {
215 WLog_ERR(TAG, "Not implemented");
216 return 0;
217 }
218
RpcObjectSetInqFn(RPC_OBJECT_INQ_FN * InquiryFn)219 RPC_STATUS RpcObjectSetInqFn(RPC_OBJECT_INQ_FN* InquiryFn)
220 {
221 WLog_ERR(TAG, "Not implemented");
222 return 0;
223 }
224
RpcObjectSetType(UUID * ObjUuid,UUID * TypeUuid)225 RPC_STATUS RpcObjectSetType(UUID* ObjUuid, UUID* TypeUuid)
226 {
227 WLog_ERR(TAG, "Not implemented");
228 return 0;
229 }
230
RpcProtseqVectorFreeA(RPC_PROTSEQ_VECTORA ** ProtseqVector)231 RPC_STATUS RpcProtseqVectorFreeA(RPC_PROTSEQ_VECTORA** ProtseqVector)
232 {
233 WLog_ERR(TAG, "Not implemented");
234 return 0;
235 }
236
RpcProtseqVectorFreeW(RPC_PROTSEQ_VECTORW ** ProtseqVector)237 RPC_STATUS RpcProtseqVectorFreeW(RPC_PROTSEQ_VECTORW** ProtseqVector)
238 {
239 WLog_ERR(TAG, "Not implemented");
240 return 0;
241 }
242
RpcServerInqBindings(RPC_BINDING_VECTOR ** BindingVector)243 RPC_STATUS RpcServerInqBindings(RPC_BINDING_VECTOR** BindingVector)
244 {
245 WLog_ERR(TAG, "Not implemented");
246 return 0;
247 }
248
RpcServerInqIf(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,RPC_MGR_EPV ** MgrEpv)249 RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV** MgrEpv)
250 {
251 WLog_ERR(TAG, "Not implemented");
252 return 0;
253 }
254
RpcServerListen(unsigned int MinimumCallThreads,unsigned int MaxCalls,unsigned int DontWait)255 RPC_STATUS RpcServerListen(unsigned int MinimumCallThreads, unsigned int MaxCalls,
256 unsigned int DontWait)
257 {
258 WLog_ERR(TAG, "Not implemented");
259 return 0;
260 }
261
RpcServerRegisterIf(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,RPC_MGR_EPV * MgrEpv)262 RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv)
263 {
264 WLog_ERR(TAG, "Not implemented");
265 return 0;
266 }
267
RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,RPC_MGR_EPV * MgrEpv,unsigned int Flags,unsigned int MaxCalls,RPC_IF_CALLBACK_FN * IfCallback)268 RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
269 unsigned int Flags, unsigned int MaxCalls,
270 RPC_IF_CALLBACK_FN* IfCallback)
271 {
272 WLog_ERR(TAG, "Not implemented");
273 return 0;
274 }
275
RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,RPC_MGR_EPV * MgrEpv,unsigned int Flags,unsigned int MaxCalls,unsigned int MaxRpcSize,RPC_IF_CALLBACK_FN * IfCallbackFn)276 RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
277 unsigned int Flags, unsigned int MaxCalls, unsigned int MaxRpcSize,
278 RPC_IF_CALLBACK_FN* IfCallbackFn)
279 {
280 WLog_ERR(TAG, "Not implemented");
281 return 0;
282 }
283
RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,unsigned int WaitForCallsToComplete)284 RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
285 unsigned int WaitForCallsToComplete)
286 {
287 WLog_ERR(TAG, "Not implemented");
288 return 0;
289 }
290
RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec,UUID * MgrTypeUuid,int RundownContextHandles)291 RPC_STATUS RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
292 int RundownContextHandles)
293 {
294 WLog_ERR(TAG, "Not implemented");
295 return 0;
296 }
297
RpcServerUseAllProtseqs(unsigned int MaxCalls,void * SecurityDescriptor)298 RPC_STATUS RpcServerUseAllProtseqs(unsigned int MaxCalls, void* SecurityDescriptor)
299 {
300 WLog_ERR(TAG, "Not implemented");
301 return 0;
302 }
303
RpcServerUseAllProtseqsEx(unsigned int MaxCalls,void * SecurityDescriptor,PRPC_POLICY Policy)304 RPC_STATUS RpcServerUseAllProtseqsEx(unsigned int MaxCalls, void* SecurityDescriptor,
305 PRPC_POLICY Policy)
306 {
307 WLog_ERR(TAG, "Not implemented");
308 return 0;
309 }
310
RpcServerUseAllProtseqsIf(unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor)311 RPC_STATUS RpcServerUseAllProtseqsIf(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
312 void* SecurityDescriptor)
313 {
314 WLog_ERR(TAG, "Not implemented");
315 return 0;
316 }
317
RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor,PRPC_POLICY Policy)318 RPC_STATUS RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
319 void* SecurityDescriptor, PRPC_POLICY Policy)
320 {
321 WLog_ERR(TAG, "Not implemented");
322 return 0;
323 }
324
RpcServerUseProtseqA(RPC_CSTR Protseq,unsigned int MaxCalls,void * SecurityDescriptor)325 RPC_STATUS RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor)
326 {
327 WLog_ERR(TAG, "Not implemented");
328 return 0;
329 }
330
RpcServerUseProtseqExA(RPC_CSTR Protseq,unsigned int MaxCalls,void * SecurityDescriptor,PRPC_POLICY Policy)331 RPC_STATUS RpcServerUseProtseqExA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor,
332 PRPC_POLICY Policy)
333 {
334 WLog_ERR(TAG, "Not implemented");
335 return 0;
336 }
337
RpcServerUseProtseqW(RPC_WSTR Protseq,unsigned int MaxCalls,void * SecurityDescriptor)338 RPC_STATUS RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor)
339 {
340 WLog_ERR(TAG, "Not implemented");
341 return 0;
342 }
343
RpcServerUseProtseqExW(RPC_WSTR Protseq,unsigned int MaxCalls,void * SecurityDescriptor,PRPC_POLICY Policy)344 RPC_STATUS RpcServerUseProtseqExW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor,
345 PRPC_POLICY Policy)
346 {
347 WLog_ERR(TAG, "Not implemented");
348 return 0;
349 }
350
RpcServerUseProtseqEpA(RPC_CSTR Protseq,unsigned int MaxCalls,RPC_CSTR Endpoint,void * SecurityDescriptor)351 RPC_STATUS RpcServerUseProtseqEpA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint,
352 void* SecurityDescriptor)
353 {
354 WLog_ERR(TAG, "Not implemented");
355 return 0;
356 }
357
RpcServerUseProtseqEpExA(RPC_CSTR Protseq,unsigned int MaxCalls,RPC_CSTR Endpoint,void * SecurityDescriptor,PRPC_POLICY Policy)358 RPC_STATUS RpcServerUseProtseqEpExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint,
359 void* SecurityDescriptor, PRPC_POLICY Policy)
360 {
361 WLog_ERR(TAG, "Not implemented");
362 return 0;
363 }
364
RpcServerUseProtseqEpW(RPC_WSTR Protseq,unsigned int MaxCalls,RPC_WSTR Endpoint,void * SecurityDescriptor)365 RPC_STATUS RpcServerUseProtseqEpW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint,
366 void* SecurityDescriptor)
367 {
368 WLog_ERR(TAG, "Not implemented");
369 return 0;
370 }
371
RpcServerUseProtseqEpExW(RPC_WSTR Protseq,unsigned int MaxCalls,RPC_WSTR Endpoint,void * SecurityDescriptor,PRPC_POLICY Policy)372 RPC_STATUS RpcServerUseProtseqEpExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint,
373 void* SecurityDescriptor, PRPC_POLICY Policy)
374 {
375 WLog_ERR(TAG, "Not implemented");
376 return 0;
377 }
378
RpcServerUseProtseqIfA(RPC_CSTR Protseq,unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor)379 RPC_STATUS RpcServerUseProtseqIfA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
380 void* SecurityDescriptor)
381 {
382 WLog_ERR(TAG, "Not implemented");
383 return 0;
384 }
385
RpcServerUseProtseqIfExA(RPC_CSTR Protseq,unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor,PRPC_POLICY Policy)386 RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
387 void* SecurityDescriptor, PRPC_POLICY Policy)
388 {
389 WLog_ERR(TAG, "Not implemented");
390 return 0;
391 }
392
RpcServerUseProtseqIfW(RPC_WSTR Protseq,unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor)393 RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
394 void* SecurityDescriptor)
395 {
396 WLog_ERR(TAG, "Not implemented");
397 return 0;
398 }
399
RpcServerUseProtseqIfExW(RPC_WSTR Protseq,unsigned int MaxCalls,RPC_IF_HANDLE IfSpec,void * SecurityDescriptor,PRPC_POLICY Policy)400 RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec,
401 void* SecurityDescriptor, PRPC_POLICY Policy)
402 {
403 WLog_ERR(TAG, "Not implemented");
404 return 0;
405 }
406
RpcServerYield()407 void RpcServerYield()
408 {
409 WLog_ERR(TAG, "Not implemented");
410 }
411
RpcMgmtStatsVectorFree(RPC_STATS_VECTOR ** StatsVector)412 RPC_STATUS RpcMgmtStatsVectorFree(RPC_STATS_VECTOR** StatsVector)
413 {
414 WLog_ERR(TAG, "Not implemented");
415 return 0;
416 }
417
RpcMgmtInqStats(RPC_BINDING_HANDLE Binding,RPC_STATS_VECTOR ** Statistics)418 RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding, RPC_STATS_VECTOR** Statistics)
419 {
420 WLog_ERR(TAG, "Not implemented");
421 return 0;
422 }
423
RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding)424 RPC_STATUS RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding)
425 {
426 WLog_ERR(TAG, "Not implemented");
427 return 0;
428 }
429
RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)430 RPC_STATUS RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)
431 {
432 WLog_ERR(TAG, "Not implemented");
433 return 0;
434 }
435
RpcMgmtWaitServerListen(void)436 RPC_STATUS RpcMgmtWaitServerListen(void)
437 {
438 WLog_ERR(TAG, "Not implemented");
439 return 0;
440 }
441
RpcMgmtSetServerStackSize(unsigned long ThreadStackSize)442 RPC_STATUS RpcMgmtSetServerStackSize(unsigned long ThreadStackSize)
443 {
444 WLog_ERR(TAG, "Not implemented");
445 return 0;
446 }
447
RpcSsDontSerializeContext(void)448 void RpcSsDontSerializeContext(void)
449 {
450 WLog_ERR(TAG, "Not implemented");
451 }
452
RpcMgmtEnableIdleCleanup(void)453 RPC_STATUS RpcMgmtEnableIdleCleanup(void)
454 {
455 WLog_ERR(TAG, "Not implemented");
456 return 0;
457 }
458
RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding,RPC_IF_ID_VECTOR ** IfIdVector)459 RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding, RPC_IF_ID_VECTOR** IfIdVector)
460 {
461 WLog_ERR(TAG, "Not implemented");
462 return 0;
463 }
464
RpcIfIdVectorFree(RPC_IF_ID_VECTOR ** IfIdVector)465 RPC_STATUS RpcIfIdVectorFree(RPC_IF_ID_VECTOR** IfIdVector)
466 {
467 WLog_ERR(TAG, "Not implemented");
468 return 0;
469 }
470
RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding,unsigned long AuthnSvc,RPC_CSTR * ServerPrincName)471 RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc,
472 RPC_CSTR* ServerPrincName)
473 {
474 WLog_ERR(TAG, "Not implemented");
475 return 0;
476 }
477
RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding,unsigned long AuthnSvc,RPC_WSTR * ServerPrincName)478 RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc,
479 RPC_WSTR* ServerPrincName)
480 {
481 WLog_ERR(TAG, "Not implemented");
482 return 0;
483 }
484
RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc,RPC_CSTR * PrincName)485 RPC_STATUS RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc, RPC_CSTR* PrincName)
486 {
487 WLog_ERR(TAG, "Not implemented");
488 return 0;
489 }
490
RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc,RPC_WSTR * PrincName)491 RPC_STATUS RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc, RPC_WSTR* PrincName)
492 {
493 WLog_ERR(TAG, "Not implemented");
494 return 0;
495 }
496
RpcEpResolveBinding(RPC_BINDING_HANDLE Binding,RPC_IF_HANDLE IfSpec)497 RPC_STATUS RpcEpResolveBinding(RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec)
498 {
499 WLog_ERR(TAG, "Not implemented");
500 return 0;
501 }
502
RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding,unsigned long EntryNameSyntax,RPC_CSTR * EntryName)503 RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax,
504 RPC_CSTR* EntryName)
505 {
506 WLog_ERR(TAG, "Not implemented");
507 return 0;
508 }
509
RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding,unsigned long EntryNameSyntax,RPC_WSTR * EntryName)510 RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax,
511 RPC_WSTR* EntryName)
512 {
513 WLog_ERR(TAG, "Not implemented");
514 return 0;
515 }
516
RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)517 RPC_STATUS RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
518 {
519 WLog_ERR(TAG, "Not implemented");
520 return 0;
521 }
522
RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)523 RPC_STATUS RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)
524 {
525 WLog_ERR(TAG, "Not implemented");
526 return 0;
527 }
528
RpcRevertToSelf()529 RPC_STATUS RpcRevertToSelf()
530 {
531 WLog_ERR(TAG, "Not implemented");
532 return 0;
533 }
534
RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding,RPC_AUTHZ_HANDLE * Privs,RPC_CSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,unsigned long * AuthzSvc)535 RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
536 RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
537 unsigned long* AuthnSvc, unsigned long* AuthzSvc)
538 {
539 WLog_ERR(TAG, "Not implemented");
540 return 0;
541 }
542
RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding,RPC_AUTHZ_HANDLE * Privs,RPC_WSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,unsigned long * AuthzSvc)543 RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
544 RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
545 unsigned long* AuthnSvc, unsigned long* AuthzSvc)
546 {
547 WLog_ERR(TAG, "Not implemented");
548 return 0;
549 }
550
RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding,RPC_AUTHZ_HANDLE * Privs,RPC_CSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,unsigned long * AuthzSvc,unsigned long Flags)551 RPC_STATUS RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
552 RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
553 unsigned long* AuthnSvc, unsigned long* AuthzSvc,
554 unsigned long Flags)
555 {
556 WLog_ERR(TAG, "Not implemented");
557 return 0;
558 }
559
RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding,RPC_AUTHZ_HANDLE * Privs,RPC_WSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,unsigned long * AuthzSvc,unsigned long Flags)560 RPC_STATUS RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
561 RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
562 unsigned long* AuthnSvc, unsigned long* AuthzSvc,
563 unsigned long Flags)
564 {
565 WLog_ERR(TAG, "Not implemented");
566 return 0;
567 }
568
RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding,RPC_CSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,RPC_AUTH_IDENTITY_HANDLE * AuthIdentity,unsigned long * AuthzSvc)569 RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName,
570 unsigned long* AuthnLevel, unsigned long* AuthnSvc,
571 RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc)
572 {
573 WLog_ERR(TAG, "Not implemented");
574 return 0;
575 }
576
RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding,RPC_WSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,RPC_AUTH_IDENTITY_HANDLE * AuthIdentity,unsigned long * AuthzSvc)577 RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName,
578 unsigned long* AuthnLevel, unsigned long* AuthnSvc,
579 RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc)
580 {
581 WLog_ERR(TAG, "Not implemented");
582 return 0;
583 }
584
RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding,RPC_CSTR ServerPrincName,unsigned long AuthnLevel,unsigned long AuthnSvc,RPC_AUTH_IDENTITY_HANDLE AuthIdentity,unsigned long AuthzSvc)585 RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName,
586 unsigned long AuthnLevel, unsigned long AuthnSvc,
587 RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc)
588 {
589 WLog_ERR(TAG, "Not implemented");
590 return 0;
591 }
592
RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding,RPC_CSTR ServerPrincName,unsigned long AuthnLevel,unsigned long AuthnSvc,RPC_AUTH_IDENTITY_HANDLE AuthIdentity,unsigned long AuthzSvc,RPC_SECURITY_QOS * SecurityQos)593 RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName,
594 unsigned long AuthnLevel, unsigned long AuthnSvc,
595 RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc,
596 RPC_SECURITY_QOS* SecurityQos)
597 {
598 WLog_ERR(TAG, "Not implemented");
599 return 0;
600 }
601
RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding,RPC_WSTR ServerPrincName,unsigned long AuthnLevel,unsigned long AuthnSvc,RPC_AUTH_IDENTITY_HANDLE AuthIdentity,unsigned long AuthzSvc)602 RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName,
603 unsigned long AuthnLevel, unsigned long AuthnSvc,
604 RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc)
605 {
606 WLog_ERR(TAG, "Not implemented");
607 return 0;
608 }
609
RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding,RPC_WSTR ServerPrincName,unsigned long AuthnLevel,unsigned long AuthnSvc,RPC_AUTH_IDENTITY_HANDLE AuthIdentity,unsigned long AuthzSvc,RPC_SECURITY_QOS * SecurityQOS)610 RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName,
611 unsigned long AuthnLevel, unsigned long AuthnSvc,
612 RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc,
613 RPC_SECURITY_QOS* SecurityQOS)
614 {
615 WLog_ERR(TAG, "Not implemented");
616 return 0;
617 }
618
RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding,RPC_CSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,RPC_AUTH_IDENTITY_HANDLE * AuthIdentity,unsigned long * AuthzSvc,unsigned long RpcQosVersion,RPC_SECURITY_QOS * SecurityQOS)619 RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName,
620 unsigned long* AuthnLevel, unsigned long* AuthnSvc,
621 RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
622 unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS)
623 {
624 WLog_ERR(TAG, "Not implemented");
625 return 0;
626 }
627
RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding,RPC_WSTR * ServerPrincName,unsigned long * AuthnLevel,unsigned long * AuthnSvc,RPC_AUTH_IDENTITY_HANDLE * AuthIdentity,unsigned long * AuthzSvc,unsigned long RpcQosVersion,RPC_SECURITY_QOS * SecurityQOS)628 RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName,
629 unsigned long* AuthnLevel, unsigned long* AuthnSvc,
630 RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
631 unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS)
632 {
633 WLog_ERR(TAG, "Not implemented");
634 return 0;
635 }
636
RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName,unsigned long AuthnSvc,RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,void * Arg)637 RPC_STATUS RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName, unsigned long AuthnSvc,
638 RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
639 {
640 WLog_ERR(TAG, "Not implemented");
641 return 0;
642 }
643
RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName,unsigned long AuthnSvc,RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,void * Arg)644 RPC_STATUS RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName, unsigned long AuthnSvc,
645 RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
646 {
647 WLog_ERR(TAG, "Not implemented");
648 return 0;
649 }
650
RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding,RPC_BINDING_HANDLE * ServerBinding)651 RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding,
652 RPC_BINDING_HANDLE* ServerBinding)
653 {
654 WLog_ERR(TAG, "Not implemented");
655 return 0;
656 }
657
RpcRaiseException(RPC_STATUS exception)658 void RpcRaiseException(RPC_STATUS exception)
659 {
660 WLog_ERR(TAG, "RpcRaiseException: 0x%08luX", exception);
661 exit((int)exception);
662 }
663
RpcTestCancel()664 RPC_STATUS RpcTestCancel()
665 {
666 WLog_ERR(TAG, "Not implemented");
667 return 0;
668 }
669
RpcServerTestCancel(RPC_BINDING_HANDLE BindingHandle)670 RPC_STATUS RpcServerTestCancel(RPC_BINDING_HANDLE BindingHandle)
671 {
672 WLog_ERR(TAG, "Not implemented");
673 return 0;
674 }
675
RpcCancelThread(void * Thread)676 RPC_STATUS RpcCancelThread(void* Thread)
677 {
678 WLog_ERR(TAG, "Not implemented");
679 return 0;
680 }
681
RpcCancelThreadEx(void * Thread,long Timeout)682 RPC_STATUS RpcCancelThreadEx(void* Thread, long Timeout)
683 {
684 WLog_ERR(TAG, "Not implemented");
685 return 0;
686 }
687
688 /**
689 * UUID Functions
690 */
691
692 static UUID UUID_NIL = {
693 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
694 };
695
UuidCreate(UUID * Uuid)696 RPC_STATUS UuidCreate(UUID* Uuid)
697 {
698 winpr_RAND_pseudo((BYTE*)Uuid, 16);
699 return RPC_S_OK;
700 }
701
UuidCreateSequential(UUID * Uuid)702 RPC_STATUS UuidCreateSequential(UUID* Uuid)
703 {
704 winpr_RAND_pseudo((BYTE*)Uuid, 16);
705 return RPC_S_OK;
706 }
707
UuidToStringA(const UUID * Uuid,RPC_CSTR * StringUuid)708 RPC_STATUS UuidToStringA(const UUID* Uuid, RPC_CSTR* StringUuid)
709 {
710 *StringUuid = (RPC_CSTR)malloc(36 + 1);
711
712 if (!(*StringUuid))
713 return RPC_S_OUT_OF_MEMORY;
714
715 if (!Uuid)
716 Uuid = &UUID_NIL;
717
718 /**
719 * Format is 32 hex digits partitioned in 5 groups:
720 * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
721 */
722 sprintf_s((char*)*StringUuid, 36 + 1, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
723 Uuid->Data1, Uuid->Data2, Uuid->Data3, Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
724 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5], Uuid->Data4[6], Uuid->Data4[7]);
725 return RPC_S_OK;
726 }
727
UuidToStringW(const UUID * Uuid,RPC_WSTR * StringUuid)728 RPC_STATUS UuidToStringW(const UUID* Uuid, RPC_WSTR* StringUuid)
729 {
730 WLog_ERR(TAG, "Not implemented");
731 return 0;
732 }
733
UuidFromStringA(RPC_CSTR StringUuid,UUID * Uuid)734 RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid)
735 {
736 int index;
737 BYTE bin[36];
738
739 if (!StringUuid)
740 return UuidCreateNil(Uuid);
741
742 if (strlen((char*)StringUuid) != 36)
743 return RPC_S_INVALID_STRING_UUID;
744
745 if ((StringUuid[8] != '-') || (StringUuid[13] != '-') || (StringUuid[18] != '-') ||
746 (StringUuid[23] != '-'))
747 {
748 return RPC_S_INVALID_STRING_UUID;
749 }
750
751 for (index = 0; index < 36; index++)
752 {
753 if ((index == 8) || (index == 13) || (index == 18) || (index == 23))
754 continue;
755
756 if ((StringUuid[index] >= '0') && (StringUuid[index] <= '9'))
757 bin[index] = StringUuid[index] - '0';
758 else if ((StringUuid[index] >= 'a') && (StringUuid[index] <= 'f'))
759 bin[index] = StringUuid[index] - 'a' + 10;
760 else if ((StringUuid[index] >= 'A') && (StringUuid[index] <= 'F'))
761 bin[index] = StringUuid[index] - 'A' + 10;
762 else
763 return RPC_S_INVALID_STRING_UUID;
764 }
765
766 Uuid->Data1 = ((bin[0] << 28) | (bin[1] << 24) | (bin[2] << 20) | (bin[3] << 16) |
767 (bin[4] << 12) | (bin[5] << 8) | (bin[6] << 4) | bin[7]);
768 Uuid->Data2 = ((bin[9] << 12) | (bin[10] << 8) | (bin[11] << 4) | bin[12]);
769 Uuid->Data3 = ((bin[14] << 12) | (bin[15] << 8) | (bin[16] << 4) | bin[17]);
770 Uuid->Data4[0] = ((bin[19] << 4) | bin[20]);
771 Uuid->Data4[1] = ((bin[21] << 4) | bin[22]);
772 Uuid->Data4[2] = ((bin[24] << 4) | bin[25]);
773 Uuid->Data4[3] = ((bin[26] << 4) | bin[27]);
774 Uuid->Data4[4] = ((bin[28] << 4) | bin[29]);
775 Uuid->Data4[5] = ((bin[30] << 4) | bin[31]);
776 Uuid->Data4[6] = ((bin[32] << 4) | bin[33]);
777 Uuid->Data4[7] = ((bin[34] << 4) | bin[35]);
778 return RPC_S_OK;
779 }
780
UuidFromStringW(RPC_WSTR StringUuid,UUID * Uuid)781 RPC_STATUS UuidFromStringW(RPC_WSTR StringUuid, UUID* Uuid)
782 {
783 WLog_ERR(TAG, "Not implemented");
784 return 0;
785 }
786
UuidCompare(const UUID * Uuid1,const UUID * Uuid2,RPC_STATUS * Status)787 signed int UuidCompare(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
788 {
789 int index;
790 *Status = RPC_S_OK;
791
792 if (!Uuid1)
793 Uuid1 = &UUID_NIL;
794
795 if (!Uuid2)
796 Uuid2 = &UUID_NIL;
797
798 if (Uuid1->Data1 != Uuid2->Data1)
799 return (Uuid1->Data1 < Uuid2->Data1) ? -1 : 1;
800
801 if (Uuid1->Data2 != Uuid2->Data2)
802 return (Uuid1->Data2 < Uuid2->Data2) ? -1 : 1;
803
804 if (Uuid1->Data3 != Uuid2->Data3)
805 return (Uuid1->Data3 < Uuid2->Data3) ? -1 : 1;
806
807 for (index = 0; index < 8; index++)
808 {
809 if (Uuid1->Data4[index] != Uuid2->Data4[index])
810 return (Uuid1->Data4[index] < Uuid2->Data4[index]) ? -1 : 1;
811 }
812
813 return 0;
814 }
815
UuidCreateNil(UUID * NilUuid)816 RPC_STATUS UuidCreateNil(UUID* NilUuid)
817 {
818 CopyMemory((void*)NilUuid, (void*)&UUID_NIL, 16);
819 return RPC_S_OK;
820 }
821
UuidEqual(const UUID * Uuid1,const UUID * Uuid2,RPC_STATUS * Status)822 int UuidEqual(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
823 {
824 return ((UuidCompare(Uuid1, Uuid2, Status) == 0) ? TRUE : FALSE);
825 }
826
UuidHash(const UUID * Uuid,RPC_STATUS * Status)827 unsigned short UuidHash(const UUID* Uuid, RPC_STATUS* Status)
828 {
829 WLog_ERR(TAG, "Not implemented");
830 return 0;
831 }
832
UuidIsNil(const UUID * Uuid,RPC_STATUS * Status)833 int UuidIsNil(const UUID* Uuid, RPC_STATUS* Status)
834 {
835 return UuidEqual(Uuid, &UUID_NIL, Status);
836 }
837
RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec,RPC_BINDING_VECTOR * BindingVector,UUID_VECTOR * UuidVector,RPC_CSTR Annotation)838 RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
839 UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
840 {
841 WLog_ERR(TAG, "Not implemented");
842 return 0;
843 }
844
RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec,RPC_BINDING_VECTOR * BindingVector,UUID_VECTOR * UuidVector,RPC_WSTR Annotation)845 RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
846 UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
847 {
848 WLog_ERR(TAG, "Not implemented");
849 return 0;
850 }
851
RpcEpRegisterA(RPC_IF_HANDLE IfSpec,RPC_BINDING_VECTOR * BindingVector,UUID_VECTOR * UuidVector,RPC_CSTR Annotation)852 RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
853 UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
854 {
855 WLog_ERR(TAG, "Not implemented");
856 return 0;
857 }
858
RpcEpRegisterW(RPC_IF_HANDLE IfSpec,RPC_BINDING_VECTOR * BindingVector,UUID_VECTOR * UuidVector,RPC_WSTR Annotation)859 RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
860 UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
861 {
862 WLog_ERR(TAG, "Not implemented");
863 return 0;
864 }
865
RpcEpUnregister(RPC_IF_HANDLE IfSpec,RPC_BINDING_VECTOR * BindingVector,UUID_VECTOR * UuidVector)866 RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
867 UUID_VECTOR* UuidVector)
868 {
869 WLog_ERR(TAG, "Not implemented");
870 return 0;
871 }
872
DceErrorInqTextA(RPC_STATUS RpcStatus,RPC_CSTR ErrorText)873 RPC_STATUS DceErrorInqTextA(RPC_STATUS RpcStatus, RPC_CSTR ErrorText)
874 {
875 WLog_ERR(TAG, "Not implemented");
876 return 0;
877 }
878
DceErrorInqTextW(RPC_STATUS RpcStatus,RPC_WSTR ErrorText)879 RPC_STATUS DceErrorInqTextW(RPC_STATUS RpcStatus, RPC_WSTR ErrorText)
880 {
881 WLog_ERR(TAG, "Not implemented");
882 return 0;
883 }
884
RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding,unsigned long InquiryType,RPC_IF_ID * IfId,unsigned long VersOption,UUID * ObjectUuid,RPC_EP_INQ_HANDLE * InquiryContext)885 RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding, unsigned long InquiryType,
886 RPC_IF_ID* IfId, unsigned long VersOption, UUID* ObjectUuid,
887 RPC_EP_INQ_HANDLE* InquiryContext)
888 {
889 WLog_ERR(TAG, "Not implemented");
890 return 0;
891 }
892
RpcMgmtEpEltInqDone(RPC_EP_INQ_HANDLE * InquiryContext)893 RPC_STATUS RpcMgmtEpEltInqDone(RPC_EP_INQ_HANDLE* InquiryContext)
894 {
895 WLog_ERR(TAG, "Not implemented");
896 return 0;
897 }
898
RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext,RPC_IF_ID * IfId,RPC_BINDING_HANDLE * Binding,UUID * ObjectUuid,RPC_CSTR * Annotation)899 RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
900 RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_CSTR* Annotation)
901 {
902 WLog_ERR(TAG, "Not implemented");
903 return 0;
904 }
905
RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext,RPC_IF_ID * IfId,RPC_BINDING_HANDLE * Binding,UUID * ObjectUuid,RPC_WSTR * Annotation)906 RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
907 RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_WSTR* Annotation)
908 {
909 WLog_ERR(TAG, "Not implemented");
910 return 0;
911 }
912
RpcMgmtEpUnregister(RPC_BINDING_HANDLE EpBinding,RPC_IF_ID * IfId,RPC_BINDING_HANDLE Binding,UUID * ObjectUuid)913 RPC_STATUS RpcMgmtEpUnregister(RPC_BINDING_HANDLE EpBinding, RPC_IF_ID* IfId,
914 RPC_BINDING_HANDLE Binding, UUID* ObjectUuid)
915 {
916 WLog_ERR(TAG, "Not implemented");
917 return 0;
918 }
919
RpcMgmtSetAuthorizationFn(RPC_MGMT_AUTHORIZATION_FN AuthorizationFn)920 RPC_STATUS RpcMgmtSetAuthorizationFn(RPC_MGMT_AUTHORIZATION_FN AuthorizationFn)
921 {
922 WLog_ERR(TAG, "Not implemented");
923 return 0;
924 }
925
RpcServerInqBindingHandle(RPC_BINDING_HANDLE * Binding)926 RPC_STATUS RpcServerInqBindingHandle(RPC_BINDING_HANDLE* Binding)
927 {
928 WLog_ERR(TAG, "Not implemented");
929 return 0;
930 }
931
932 #endif
933