FreeRDP
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Modules Pages
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%08luX", 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 winpr_RAND_pseudo(Uuid, 16);
824 return RPC_S_OK;
825}
826
827RPC_STATUS UuidCreateSequential(UUID* Uuid)
828{
829 winpr_RAND_pseudo(Uuid, 16);
830 return RPC_S_OK;
831}
832
833RPC_STATUS UuidToStringA(const UUID* Uuid, RPC_CSTR* StringUuid)
834{
835 *StringUuid = (RPC_CSTR)malloc(36 + 1);
836
837 if (!(*StringUuid))
838 return RPC_S_OUT_OF_MEMORY;
839
840 if (!Uuid)
841 Uuid = &UUID_NIL;
842
847 (void)sprintf_s((char*)*StringUuid, 36 + 1, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
848 Uuid->Data1, Uuid->Data2, Uuid->Data3, Uuid->Data4[0], Uuid->Data4[1],
849 Uuid->Data4[2], Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5], Uuid->Data4[6],
850 Uuid->Data4[7]);
851 return RPC_S_OK;
852}
853
854RPC_STATUS UuidToStringW(WINPR_ATTR_UNUSED const UUID* Uuid, WINPR_ATTR_UNUSED RPC_WSTR* StringUuid)
855{
856 WLog_ERR(TAG, "Not implemented");
857 return 0;
858}
859
860RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid)
861{
862 BYTE bin[36] = { 0 };
863
864 if (!StringUuid)
865 return UuidCreateNil(Uuid);
866
867 const size_t slen = 2 * sizeof(UUID) + 4;
868 if (strnlen(StringUuid, slen) != slen)
869 return RPC_S_INVALID_STRING_UUID;
870
871 if ((StringUuid[8] != '-') || (StringUuid[13] != '-') || (StringUuid[18] != '-') ||
872 (StringUuid[23] != '-'))
873 {
874 return RPC_S_INVALID_STRING_UUID;
875 }
876
877 for (size_t index = 0; index < 36; index++)
878 {
879 if ((index == 8) || (index == 13) || (index == 18) || (index == 23))
880 continue;
881
882 if ((StringUuid[index] >= '0') && (StringUuid[index] <= '9'))
883 bin[index] = (StringUuid[index] - '0') & 0xFF;
884 else if ((StringUuid[index] >= 'a') && (StringUuid[index] <= 'f'))
885 bin[index] = (StringUuid[index] - 'a' + 10) & 0xFF;
886 else if ((StringUuid[index] >= 'A') && (StringUuid[index] <= 'F'))
887 bin[index] = (StringUuid[index] - 'A' + 10) & 0xFF;
888 else
889 return RPC_S_INVALID_STRING_UUID;
890 }
891
892 Uuid->Data1 = (UINT32)((bin[0] << 28) | (bin[1] << 24) | (bin[2] << 20) | (bin[3] << 16) |
893 (bin[4] << 12) | (bin[5] << 8) | (bin[6] << 4) | bin[7]);
894 Uuid->Data2 = (UINT16)((bin[9] << 12) | (bin[10] << 8) | (bin[11] << 4) | bin[12]);
895 Uuid->Data3 = (UINT16)((bin[14] << 12) | (bin[15] << 8) | (bin[16] << 4) | bin[17]);
896 Uuid->Data4[0] = (UINT8)((bin[19] << 4) | bin[20]);
897 Uuid->Data4[1] = (UINT8)((bin[21] << 4) | bin[22]);
898 Uuid->Data4[2] = (UINT8)((bin[24] << 4) | bin[25]);
899 Uuid->Data4[3] = (UINT8)((bin[26] << 4) | bin[27]);
900 Uuid->Data4[4] = (UINT8)((bin[28] << 4) | bin[29]);
901 Uuid->Data4[5] = (UINT8)((bin[30] << 4) | bin[31]);
902 Uuid->Data4[6] = (UINT8)((bin[32] << 4) | bin[33]);
903 Uuid->Data4[7] = (UINT8)((bin[34] << 4) | bin[35]);
904 return RPC_S_OK;
905}
906
907RPC_STATUS UuidFromStringW(WINPR_ATTR_UNUSED RPC_WSTR StringUuid, WINPR_ATTR_UNUSED UUID* Uuid)
908{
909 WLog_ERR(TAG, "Not implemented");
910 return 0;
911}
912
913signed int UuidCompare(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
914{
915 *Status = RPC_S_OK;
916
917 if (!Uuid1)
918 Uuid1 = &UUID_NIL;
919
920 if (!Uuid2)
921 Uuid2 = &UUID_NIL;
922
923 if (Uuid1->Data1 != Uuid2->Data1)
924 return (Uuid1->Data1 < Uuid2->Data1) ? -1 : 1;
925
926 if (Uuid1->Data2 != Uuid2->Data2)
927 return (Uuid1->Data2 < Uuid2->Data2) ? -1 : 1;
928
929 if (Uuid1->Data3 != Uuid2->Data3)
930 return (Uuid1->Data3 < Uuid2->Data3) ? -1 : 1;
931
932 for (int index = 0; index < 8; index++)
933 {
934 if (Uuid1->Data4[index] != Uuid2->Data4[index])
935 return (Uuid1->Data4[index] < Uuid2->Data4[index]) ? -1 : 1;
936 }
937
938 return 0;
939}
940
941RPC_STATUS UuidCreateNil(UUID* NilUuid)
942{
943 CopyMemory((void*)NilUuid, (void*)&UUID_NIL, 16);
944 return RPC_S_OK;
945}
946
947int UuidEqual(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
948{
949 return ((UuidCompare(Uuid1, Uuid2, Status) == 0) ? TRUE : FALSE);
950}
951
952unsigned short UuidHash(WINPR_ATTR_UNUSED const UUID* Uuid, WINPR_ATTR_UNUSED RPC_STATUS* Status)
953{
954 WLog_ERR(TAG, "Not implemented");
955 return 0;
956}
957
958int UuidIsNil(const UUID* Uuid, RPC_STATUS* Status)
959{
960 return UuidEqual(Uuid, &UUID_NIL, Status);
961}
962
963RPC_STATUS RpcEpRegisterNoReplaceA(WINPR_ATTR_UNUSED RPC_IF_HANDLE IfSpec,
964 WINPR_ATTR_UNUSED RPC_BINDING_VECTOR* BindingVector,
965 WINPR_ATTR_UNUSED UUID_VECTOR* UuidVector,
966 WINPR_ATTR_UNUSED RPC_CSTR Annotation)
967{
968 WLog_ERR(TAG, "Not implemented");
969 return 0;
970}
971
972RPC_STATUS RpcEpRegisterNoReplaceW(WINPR_ATTR_UNUSED RPC_IF_HANDLE IfSpec,
973 WINPR_ATTR_UNUSED RPC_BINDING_VECTOR* BindingVector,
974 WINPR_ATTR_UNUSED UUID_VECTOR* UuidVector,
975 WINPR_ATTR_UNUSED RPC_WSTR Annotation)
976{
977 WLog_ERR(TAG, "Not implemented");
978 return 0;
979}
980
981RPC_STATUS RpcEpRegisterA(WINPR_ATTR_UNUSED RPC_IF_HANDLE IfSpec,
982 WINPR_ATTR_UNUSED RPC_BINDING_VECTOR* BindingVector,
983 WINPR_ATTR_UNUSED UUID_VECTOR* UuidVector,
984 WINPR_ATTR_UNUSED RPC_CSTR Annotation)
985{
986 WLog_ERR(TAG, "Not implemented");
987 return 0;
988}
989
990RPC_STATUS RpcEpRegisterW(WINPR_ATTR_UNUSED RPC_IF_HANDLE IfSpec,
991 WINPR_ATTR_UNUSED RPC_BINDING_VECTOR* BindingVector,
992 WINPR_ATTR_UNUSED UUID_VECTOR* UuidVector,
993 WINPR_ATTR_UNUSED RPC_WSTR Annotation)
994{
995 WLog_ERR(TAG, "Not implemented");
996 return 0;
997}
998
999RPC_STATUS RpcEpUnregister(WINPR_ATTR_UNUSED RPC_IF_HANDLE IfSpec,
1000 WINPR_ATTR_UNUSED RPC_BINDING_VECTOR* BindingVector,
1001 WINPR_ATTR_UNUSED UUID_VECTOR* UuidVector)
1002{
1003 WLog_ERR(TAG, "Not implemented");
1004 return 0;
1005}
1006
1007RPC_STATUS DceErrorInqTextA(WINPR_ATTR_UNUSED RPC_STATUS RpcStatus,
1008 WINPR_ATTR_UNUSED RPC_CSTR ErrorText)
1009{
1010 WLog_ERR(TAG, "Not implemented");
1011 return 0;
1012}
1013
1014RPC_STATUS DceErrorInqTextW(WINPR_ATTR_UNUSED RPC_STATUS RpcStatus,
1015 WINPR_ATTR_UNUSED RPC_WSTR ErrorText)
1016{
1017 WLog_ERR(TAG, "Not implemented");
1018 return 0;
1019}
1020
1021RPC_STATUS RpcMgmtEpEltInqBegin(WINPR_ATTR_UNUSED RPC_BINDING_HANDLE EpBinding,
1022 WINPR_ATTR_UNUSED unsigned long InquiryType,
1023 WINPR_ATTR_UNUSED RPC_IF_ID* IfId,
1024 WINPR_ATTR_UNUSED unsigned long VersOption,
1025 WINPR_ATTR_UNUSED UUID* ObjectUuid,
1026 WINPR_ATTR_UNUSED RPC_EP_INQ_HANDLE* InquiryContext)
1027{
1028 WLog_ERR(TAG, "Not implemented");
1029 return 0;
1030}
1031
1032RPC_STATUS RpcMgmtEpEltInqDone(WINPR_ATTR_UNUSED RPC_EP_INQ_HANDLE* InquiryContext)
1033{
1034 WLog_ERR(TAG, "Not implemented");
1035 return 0;
1036}
1037
1038RPC_STATUS RpcMgmtEpEltInqNextA(WINPR_ATTR_UNUSED RPC_EP_INQ_HANDLE InquiryContext,
1039 WINPR_ATTR_UNUSED RPC_IF_ID* IfId,
1040 WINPR_ATTR_UNUSED RPC_BINDING_HANDLE* Binding,
1041 WINPR_ATTR_UNUSED UUID* ObjectUuid,
1042 WINPR_ATTR_UNUSED RPC_CSTR* Annotation)
1043{
1044 WLog_ERR(TAG, "Not implemented");
1045 return 0;
1046}
1047
1048RPC_STATUS RpcMgmtEpEltInqNextW(WINPR_ATTR_UNUSED RPC_EP_INQ_HANDLE InquiryContext,
1049 WINPR_ATTR_UNUSED RPC_IF_ID* IfId,
1050 WINPR_ATTR_UNUSED RPC_BINDING_HANDLE* Binding,
1051 WINPR_ATTR_UNUSED UUID* ObjectUuid,
1052 WINPR_ATTR_UNUSED RPC_WSTR* Annotation)
1053{
1054 WLog_ERR(TAG, "Not implemented");
1055 return 0;
1056}
1057
1058RPC_STATUS RpcMgmtEpUnregister(WINPR_ATTR_UNUSED RPC_BINDING_HANDLE EpBinding,
1059 WINPR_ATTR_UNUSED RPC_IF_ID* IfId,
1060 WINPR_ATTR_UNUSED RPC_BINDING_HANDLE Binding,
1061 WINPR_ATTR_UNUSED UUID* ObjectUuid)
1062{
1063 WLog_ERR(TAG, "Not implemented");
1064 return 0;
1065}
1066
1067RPC_STATUS RpcMgmtSetAuthorizationFn(WINPR_ATTR_UNUSED RPC_MGMT_AUTHORIZATION_FN AuthorizationFn)
1068{
1069 WLog_ERR(TAG, "Not implemented");
1070 return 0;
1071}
1072
1073RPC_STATUS RpcServerInqBindingHandle(WINPR_ATTR_UNUSED RPC_BINDING_HANDLE* Binding)
1074{
1075 WLog_ERR(TAG, "Not implemented");
1076 return 0;
1077}
1078
1079#endif
RPC_BINDING_VECTOR
Definition winpr/include/winpr/rpc.h:85
RPC_IF_ID_VECTOR
Definition winpr/include/winpr/rpc.h:197
RPC_IF_ID
Definition winpr/include/winpr/rpc.h:101
RPC_POLICY
Definition winpr/include/winpr/rpc.h:173
RPC_PROTSEQ_VECTORA
Definition winpr/include/winpr/rpc.h:155
RPC_PROTSEQ_VECTORW
Definition winpr/include/winpr/rpc.h:161
RPC_SECURITY_QOS
Definition winpr/include/winpr/rpc.h:259
RPC_STATS_VECTOR
Definition winpr/include/winpr/rpc.h:186
UUID_VECTOR
Definition winpr/include/winpr/rpc.h:92
UUID
Definition wtypes.h:252