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