rpcdce.d

Revision 180, 19.4 kB (checked in by smjg, 5 years ago)
Added rassapi, rpcdce2, reason; updated versioning to include Windows Vista; a few cleanups

Line
1	/***********************************************************************\
2	* rpcdce.d *
3	* *
4	* Windows API header module *
5	* *
6	* Translated from MinGW Windows headers *
7	* *
8	* Placed into public domain *
9	\***********************************************************************/
10	module win32.rpcdce;
11	pragma(lib, "Rpcrt4.lib");
12
13	// TODO: I think MinGW got this wrong. RPC_UNICODE_SUPPORTED should be
14	// replaced aliases for version(Unicode)
15
16	public import win32.rpcdcep;
17	private import win32.basetyps, win32.w32api, win32.windef;
18
19	// FIXME: clean up Windows version support
20
21	alias UUID uuid_t;
22	alias UUID_VECTOR uuid_vector_t;
23	alias void RPC_MGR_EPV;
24
25	// for RpcMgmtSetComTimeout()
26	enum : uint {
27	RPC_C_BINDING_MIN_TIMEOUT = 0,
28	RPC_C_BINDING_DEFAULT_TIMEOUT = 5,
29	RPC_C_BINDING_MAX_TIMEOUT = 9,
30	RPC_C_BINDING_INFINITE_TIMEOUT = 10
31	}
32
33	const RPC_C_CANCEL_INFINITE_TIMEOUT= -1;
34	const RPC_C_LISTEN_MAX_CALLS_DEFAULT=1234;
35	const RPC_C_PROTSEQ_MAX_REQS_DEFAULT=10;
36	const RPC_C_BIND_TO_ALL_NICS=1;
37	const RPC_C_USE_INTERNET_PORT=1;
38	const RPC_C_USE_INTRANET_PORT=2;
39
40	// for RPC_STATS_VECTOR, used by RpcMgmyInqStats
41	enum : uint {
42	RPC_C_STATS_CALLS_IN = 0,
43	RPC_C_STATS_CALLS_OUT,
44	RPC_C_STATS_PKTS_IN,
45	RPC_C_STATS_PKTS_OUT
46	}
47
48	const RPC_IF_AUTOLISTEN=0x0001;
49	const RPC_IF_OLE=2;
50	const RPC_C_MGMT_INQ_IF_IDS=0;
51	const RPC_C_MGMT_INQ_PRINC_NAME=1;
52	const RPC_C_MGMT_INQ_STATS=2;
53	const RPC_C_MGMT_IS_SERVER_LISTEN=3;
54	const RPC_C_MGMT_STOP_SERVER_LISTEN=4;
55
56	// Inquiry Type for RpcMgmtEpEltInqBegin()
57	enum : uint {
58	RPC_C_EP_ALL_ELTS = 0,
59	RPC_C_EP_MATCH_BY_IF,
60	RPC_C_EP_MATCH_BY_OBJ,
61	RPC_C_EP_MATCH_BY_BOTH
62	}
63
64	// for RpcMgmtEpEltInqNext()
65	enum : uint {
66	RPC_C_VERS_ALL = 1,
67	RPC_C_VERS_COMPATIBLE,
68	RPC_C_VERS_EXACT,
69	RPC_C_VERS_MAJOR_ONLY,
70	RPC_C_VERS_UPTO
71	}
72
73	const DCE_C_ERROR_STRING_LEN=256;
74	const RPC_C_PARM_MAX_PACKET_LENGTH=1;
75	const RPC_C_PARM_BUFFER_LENGTH=2;
76	const RPC_C_AUTHN_LEVEL_DEFAULT=0;
77	const RPC_C_AUTHN_LEVEL_NONE=1;
78	const RPC_C_AUTHN_LEVEL_CONNECT=2;
79	const RPC_C_AUTHN_LEVEL_CALL=3;
80	const RPC_C_AUTHN_LEVEL_PKT=4;
81	const RPC_C_AUTHN_LEVEL_PKT_INTEGRITY=5;
82	const RPC_C_AUTHN_LEVEL_PKT_PRIVACY=6;
83	const RPC_C_IMP_LEVEL_ANONYMOUS=1;
84	const RPC_C_IMP_LEVEL_IDENTIFY=2;
85	const RPC_C_IMP_LEVEL_IMPERSONATE=3;
86	const RPC_C_IMP_LEVEL_DELEGATE=4;
87	const RPC_C_QOS_IDENTITY_STATIC=0;
88	const RPC_C_QOS_IDENTITY_DYNAMIC=1;
89	const RPC_C_QOS_CAPABILITIES_DEFAULT=0;
90	const RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH=1;
91
92	// These enums were buggy in MinGW !
93	const RPC_C_PROTECT_LEVEL_DEFAULT = RPC_C_AUTHN_LEVEL_DEFAULT;
94	const RPC_C_PROTECT_LEVEL_NONE = RPC_C_AUTHN_LEVEL_NONE;
95	const RPC_C_PROTECT_LEVEL_CONNECT = RPC_C_AUTHN_LEVEL_CONNECT;
96	const RPC_C_PROTECT_LEVEL_CALL = RPC_C_AUTHN_LEVEL_CALL;
97	const RPC_C_PROTECT_LEVEL_PKT = RPC_C_AUTHN_LEVEL_PKT;
98	const RPC_C_PROTECT_LEVEL_PKT_INTEGRITY = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY;
99	const RPC_C_PROTECT_LEVEL_PKT_PRIVACY = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
100
101	const RPC_C_AUTHN_NONE=0;
102	const RPC_C_AUTHN_DCE_PRIVATE=1;
103	const RPC_C_AUTHN_DCE_PUBLIC=2;
104	const RPC_C_AUTHN_DEC_PUBLIC=4;
105	const RPC_C_AUTHN_WINNT=10;
106	const RPC_C_AUTHN_DEFAULT=0xFFFFFFFF;
107	//const RPC_C_SECURITY_QOS_VERSION=L; // FIXME(MinGW): This is nonsense!
108	const SEC_WINNT_AUTH_IDENTITY_ANSI=0x1;
109	const SEC_WINNT_AUTH_IDENTITY_UNICODE=0x2;
110	const RPC_C_AUTHZ_NONE=0;
111	const RPC_C_AUTHZ_NAME=1;
112	const RPC_C_AUTHZ_DCE=2;
113	const RPC_C_AUTHZ_DEFAULT=0xFFFFFFFF;
114
115	alias I_RPC_HANDLE RPC_BINDING_HANDLE;
116	alias RPC_BINDING_HANDLE handle_t;
117
118	struct RPC_BINDING_VECTOR {
119	uint Count;
120	RPC_BINDING_HANDLE BindingH[1];
121	}
122
123	alias RPC_BINDING_HANDLE rpc_binding_handle_t;
124	alias RPC_BINDING_VECTOR rpc_binding_vector_t;
125
126
127	struct UUID_VECTOR {
128	uint Count;
129	UUID* Uuid[1];
130	}
131
132	alias void* RPC_IF_HANDLE;
133
134	struct RPC_IF_ID {
135	UUID Uuid;
136	ushort VersMajor;
137	ushort VersMinor;
138	}
139
140	struct RPC_POLICY {
141	uint Length;
142	uint EndpointFlags;
143	uint NICFlags;
144	}
145	alias RPC_POLICY* PRPC_POLICY;
146
147	extern (Windows) {
148	alias void function(UUID, UUID, RPC_STATUS*) RPC_OBJECT_INQ_FN;
149	alias RPC_STATUS function(RPC_IF_HANDLE, void*) RPC_IF_CALLBACK_FN;
150	}
151
152	struct RPC_STATS_VECTOR {
153	uint Count;
154	uint[1] Stats;
155	}
156
157	struct RPC_IF_ID_VECTOR {
158	uint Count;
159	RPC_IF_ID*[1] IfId;
160	}
161	alias HANDLE RPC_AUTH_IDENTITY_HANDLE, RPC_AUTHZ_HANDLE;
162
163	struct RPC_SECURITY_QOS {
164	uint Version;
165	uint Capabilities;
166	uint IdentityTracking;
167	uint ImpersonationType;
168	}
169	alias RPC_SECURITY_QOS* PRPC_SECURITY_QOS;
170
171	struct SEC_WINNT_AUTH_IDENTITY_W {
172	ushort* User;
173	uint UserLength;
174	ushort* Domain;
175	uint DomainLength;
176	ushort* Password;
177	uint PasswordLength;
178	uint Flags;
179	}
180	alias SEC_WINNT_AUTH_IDENTITY_W* PSEC_WINNT_AUTH_IDENTITY_W;
181
182	struct SEC_WINNT_AUTH_IDENTITY_A {
183	ubyte* User;
184	uint UserLength;
185	ubyte* Domain;
186	uint DomainLength;
187	ubyte* Password;
188	uint PasswordLength;
189	uint Flags;
190	}
191	alias SEC_WINNT_AUTH_IDENTITY_A* PSEC_WINNT_AUTH_IDENTITY_A;
192
193	struct RPC_CLIENT_INFORMATION1 {
194	ubyte* UserName;
195	ubyte* ComputerName;
196	ushort Privilege;
197	uint AuthFlags;
198	}
199	alias RPC_CLIENT_INFORMATION1* PRPC_CLIENT_INFORMATION1;
200	alias I_RPC_HANDLE* RPC_EP_INQ_HANDLE;
201	extern (Windows) {
202	alias int function(RPC_BINDING_HANDLE, uint, RPC_STATUS*) RPC_MGMT_AUTHORIZATION_FN;
203	}
204
205	static if(_WIN32_WINNT_ONLY) {
206
207	struct RPC_PROTSEQ_VECTORA {
208	uint Count;
209	ubyte*[1] Protseq;
210	}
211
212	struct RPC_PROTSEQ_VECTORW {
213	uint Count;
214	ushort*[1] Protseq;
215	}
216
217	extern (Windows) {
218	RPC_STATUS RpcBindingFromStringBindingA(char, RPC_BINDING_HANDLE);
219	RPC_STATUS RpcBindingFromStringBindingW(wchar, RPC_BINDING_HANDLE);
220	RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE, char**);
221	RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE, wchar**);
222	RPC_STATUS RpcStringBindingComposeA(char, char, char, char, char, char*);
223	RPC_STATUS RpcStringBindingComposeW(wchar, wchar, wchar, wchar, wchar, wchar*);
224	RPC_STATUS RpcStringBindingParseA(char, char, char, char, char, char*);
225	RPC_STATUS RpcStringBindingParseW(wchar, wchar, wchar, wchar, wchar, wchar*);
226	RPC_STATUS RpcStringFreeA(char**);
227	RPC_STATUS RpcStringFreeW(wchar**);
228	RPC_STATUS RpcNetworkIsProtseqValidA(char*);
229	RPC_STATUS RpcNetworkIsProtseqValidW(wchar*);
230	RPC_STATUS RpcNetworkInqProtseqsA(RPC_PROTSEQ_VECTORA**);
231	RPC_STATUS RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW**);
232	RPC_STATUS RpcProtseqVectorFreeA(RPC_PROTSEQ_VECTORA**);
233	RPC_STATUS RpcProtseqVectorFreeW(RPC_PROTSEQ_VECTORW**);
234	RPC_STATUS RpcServerUseProtseqA(char, uint, void);
235	RPC_STATUS RpcServerUseProtseqW(wchar, uint, void);
236	RPC_STATUS RpcServerUseProtseqExA(char, uint MaxCalls, void, PRPC_POLICY);
237	RPC_STATUS RpcServerUseProtseqExW(wchar, uint, void, PRPC_POLICY);
238	RPC_STATUS RpcServerUseProtseqEpA(char, uint, char, void*);
239	RPC_STATUS RpcServerUseProtseqEpExA(char, uint, char, void*, PRPC_POLICY);
240	RPC_STATUS RpcServerUseProtseqEpW(wchar, uint, wchar, void*);
241	RPC_STATUS RpcServerUseProtseqEpExW(wchar, uint, wchar, void*, PRPC_POLICY);
242	RPC_STATUS RpcServerUseProtseqIfA(char, uint, RPC_IF_HANDLE, void);
243	RPC_STATUS RpcServerUseProtseqIfExA(char, uint, RPC_IF_HANDLE, void, PRPC_POLICY);
244	RPC_STATUS RpcServerUseProtseqIfW(wchar, uint, RPC_IF_HANDLE, void);
245	RPC_STATUS RpcServerUseProtseqIfExW(wchar, uint, RPC_IF_HANDLE, void, PRPC_POLICY);
246	RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE, uint, char**);
247	RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE, uint, wchar**);
248	RPC_STATUS RpcServerInqDefaultPrincNameA(uint, char**);
249	RPC_STATUS RpcServerInqDefaultPrincNameW(uint, wchar**);
250	RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE, uint, char**);
251	RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE, uint, wchar**);
252	RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE, RPC_AUTHZ_HANDLE, char, uint, uint, uint);
253	RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE, RPC_AUTHZ_HANDLE, wchar, uint, uint, uint);
254	RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE, char*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint*);
255	RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE, wchar*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint*);
256	RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE, char*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint);
257	RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE, char, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint, RPC_SECURITY_QOS);
258	RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE, wchar*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint);
259	RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE, wchar, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint, RPC_SECURITY_QOS);
260	RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE, char*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint, uint, RPC_SECURITY_QOS);
261	RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE, wchar*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint, uint, RPC_SECURITY_QOS);
262	alias void function(void, wchar, uint, void*, RPC_STATUS) RPC_AUTH_KEY_RETRIEVAL_FN;
263	RPC_STATUS RpcServerRegisterAuthInfoA(char, uint, RPC_AUTH_KEY_RETRIEVAL_FN, void);
264	RPC_STATUS RpcServerRegisterAuthInfoW(wchar, uint, RPC_AUTH_KEY_RETRIEVAL_FN, void);
265	RPC_STATUS UuidToStringA(UUID, char*);
266	RPC_STATUS UuidFromStringA(char, UUID);
267	RPC_STATUS UuidToStringW(UUID, wchar*);
268	RPC_STATUS UuidFromStringW(wchar, UUID);
269	RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, char*);
270	RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, wchar*);
271	RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, char*);
272	RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, wchar*);
273	RPC_STATUS DceErrorInqTextA(RPC_STATUS, char*);
274	RPC_STATUS DceErrorInqTextW(RPC_STATUS, wchar*);
275	RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE, RPC_IF_ID, RPC_BINDING_HANDLE, UUID, char*);
276	RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE, RPC_IF_ID, RPC_BINDING_HANDLE, UUID, wchar*);
277
278	// MinGW erroneously had these in rpc.h
279	RPC_STATUS RpcImpersonateClient(RPC_BINDING_HANDLE);
280	RPC_STATUS RpcRevertToSelf();
281	}
282
283	version(Unicode) {
284	alias RPC_PROTSEQ_VECTORW RPC_PROTSEQ_VECTOR;
285	alias SEC_WINNT_AUTH_IDENTITY_W SEC_WINNT_AUTH_IDENTITY;
286	alias PSEC_WINNT_AUTH_IDENTITY_W PSEC_WINNT_AUTH_IDENTITY;
287	alias RpcMgmtEpEltInqNextW RpcMgmtEpEltInqNext;
288	alias RpcBindingFromStringBindingW RpcBindingFromStringBinding;
289	alias RpcBindingToStringBindingW RpcBindingToStringBinding;
290	alias RpcStringBindingComposeW RpcStringBindingCompose;
291	alias RpcStringBindingParseW RpcStringBindingParse;
292	alias RpcStringFreeW RpcStringFree;
293	alias RpcNetworkIsProtseqValidW RpcNetworkIsProtseqValid;
294	alias RpcNetworkInqProtseqsW RpcNetworkInqProtseqs;
295	alias RpcProtseqVectorFreeW RpcProtseqVectorFree;
296	alias RpcServerUseProtseqW RpcServerUseProtseq;
297	alias RpcServerUseProtseqExW RpcServerUseProtseqEx;
298	alias RpcServerUseProtseqEpW RpcServerUseProtseqEp;
299	alias RpcServerUseProtseqEpExW RpcServerUseProtseqEpEx;
300	alias RpcServerUseProtseqIfW RpcServerUseProtseqIf;
301	alias RpcServerUseProtseqIfExW RpcServerUseProtseqIfEx;
302	alias RpcMgmtInqServerPrincNameW RpcMgmtInqServerPrincName;
303	alias RpcServerInqDefaultPrincNameW RpcServerInqDefaultPrincName;
304	alias RpcNsBindingInqEntryNameW RpcNsBindingInqEntryName;
305	alias RpcBindingInqAuthClientW RpcBindingInqAuthClient;
306	alias RpcBindingInqAuthInfoW RpcBindingInqAuthInfo;
307	alias RpcBindingSetAuthInfoW RpcBindingSetAuthInfo;
308	alias RpcServerRegisterAuthInfoW RpcServerRegisterAuthInfo;
309	alias RpcBindingInqAuthInfoExW RpcBindingInqAuthInfoEx;
310	alias RpcBindingSetAuthInfoExW RpcBindingSetAuthInfoEx;
311	alias UuidFromStringW UuidFromString;
312	alias UuidToStringW UuidToString;
313	alias RpcEpRegisterNoReplaceW RpcEpRegisterNoReplace;
314	alias RpcEpRegisterW RpcEpRegister;
315	alias DceErrorInqTextW DceErrorInqText;
316	} else { // Ansi
317	alias RPC_PROTSEQ_VECTORA RPC_PROTSEQ_VECTOR;
318	alias SEC_WINNT_AUTH_IDENTITY_A SEC_WINNT_AUTH_IDENTITY;
319	alias PSEC_WINNT_AUTH_IDENTITY_A PSEC_WINNT_AUTH_IDENTITY;
320	alias RpcMgmtEpEltInqNextA RpcMgmtEpEltInqNext;
321	alias RpcBindingFromStringBindingA RpcBindingFromStringBinding;
322	alias RpcBindingToStringBindingA RpcBindingToStringBinding;
323	alias RpcStringBindingComposeA RpcStringBindingCompose;
324	alias RpcStringBindingParseA RpcStringBindingParse;
325	alias RpcStringFreeA RpcStringFree;
326	alias RpcNetworkIsProtseqValidA RpcNetworkIsProtseqValid;
327	alias RpcNetworkInqProtseqsA RpcNetworkInqProtseqs;
328	alias RpcProtseqVectorFreeA RpcProtseqVectorFree;
329	alias RpcServerUseProtseqA RpcServerUseProtseq;
330	alias RpcServerUseProtseqExA RpcServerUseProtseqEx;
331	alias RpcServerUseProtseqEpA RpcServerUseProtseqEp;
332	alias RpcServerUseProtseqEpExA RpcServerUseProtseqEpEx;
333	alias RpcServerUseProtseqIfA RpcServerUseProtseqIf;
334	alias RpcServerUseProtseqIfExA RpcServerUseProtseqIfEx;
335	alias RpcMgmtInqServerPrincNameA RpcMgmtInqServerPrincName;
336	alias RpcServerInqDefaultPrincNameA RpcServerInqDefaultPrincName;
337	alias RpcNsBindingInqEntryNameA RpcNsBindingInqEntryName;
338	alias RpcBindingInqAuthClientA RpcBindingInqAuthClient;
339	alias RpcBindingInqAuthInfoA RpcBindingInqAuthInfo;
340	alias RpcBindingSetAuthInfoA RpcBindingSetAuthInfo;
341	alias RpcServerRegisterAuthInfoA RpcServerRegisterAuthInfo;
342	alias RpcBindingInqAuthInfoExA RpcBindingInqAuthInfoEx;
343	alias RpcBindingSetAuthInfoExA RpcBindingSetAuthInfoEx;
344	alias UuidFromStringA UuidFromString;
345	alias UuidToStringA UuidToString;
346	alias RpcEpRegisterNoReplaceA RpcEpRegisterNoReplace;
347	alias RpcEpRegisterA RpcEpRegister;
348	alias DceErrorInqTextA DceErrorInqText;
349	} //#endif // UNICODE
350
351	} else { // _WIN32_WINNT_ONLY
352
353	struct RPC_PROTSEQ_VECTOR {
354	uint Count;
355	ubyte* Protseq[1];
356	}
357	// versions without Unicode.
358	RPC_STATUS RpcBindingFromStringBinding(char, RPC_BINDING_HANDLE);
359	RPC_STATUS RpcBindingToStringBinding(RPC_BINDING_HANDLE, char**);
360	RPC_STATUS RpcStringBindingCompose(char, char, char, char, char, char*);
361	RPC_STATUS RpcStringBindingParse(char, char, char, char, char, char*);
362	RPC_STATUS RpcStringFree(char**);
363	RPC_STATUS RpcNetworkIsProtseqValid(char*);
364	RPC_STATUS RpcNetworkInqProtseqs(RPC_PROTSEQ_VECTOR**);
365	RPC_STATUS RpcServerInqBindings(RPC_BINDING_VECTOR**);
366	RPC_STATUS RpcServerUseProtseq(char, uint, void);
367	RPC_STATUS RpcServerUseProtseqEx(char, uint, void, PRPC_POLICY);
368	RPC_STATUS RpcServerUseProtseqEp(char, uint, char, void*);
369	RPC_STATUS RpcServerUseProtseqEpEx(char, uint, char, void*, PRPC_POLICY);
370	RPC_STATUS RpcServerUseProtseqIf(char, uint, RPC_IF_HANDLE, void);
371	RPC_STATUS RpcServerUseProtseqIfEx(char, uint, RPC_IF_HANDLE, void, PRPC_POLICY);
372	RPC_STATUS RpcMgmtInqServerPrincName(RPC_BINDING_HANDLE, uint, char**);
373	RPC_STATUS RpcServerInqDefaultPrincName(uint, char**);
374	RPC_STATUS RpcNsBindingInqEntryName(RPC_BINDING_HANDLE, uint, char**);
375	RPC_STATUS RpcBindingInqAuthClient(RPC_BINDING_HANDLE, RPC_AUTHZ_HANDLE, char, uint, uint, uint);
376	RPC_STATUS RpcBindingInqAuthInfo(RPC_BINDING_HANDLE, char*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint*);
377	RPC_STATUS RpcBindingSetAuthInfo(RPC_BINDING_HANDLE, char*, uint, uint, RPC_AUTH_IDENTITY_HANDLE, uint);
378	alias void function(void, char, uint, void*, RPC_STATUS) RPC_AUTH_KEY_RETRIEVAL_FN;
379	RPC_STATUS RpcServerRegisterAuthInfo(char, uint, RPC_AUTH_KEY_RETRIEVAL_FN, void);
380	RPC_STATUS UuidToString(UUID, char*);
381	RPC_STATUS UuidFromString(char, UUID);
382	RPC_STATUS RpcEpRegisterNoReplace(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, char*);
383	RPC_STATUS RpcEpRegister(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR, char*);
384	RPC_STATUS DceErrorInqText(RPC_STATUS, char*);
385	RPC_STATUS RpcMgmtEpEltInqNext(RPC_EP_INQ_HANDLE, RPC_IF_ID, RPC_BINDING_HANDLE, char**);
386	}// _WIN32_WINNT_ONLY
387
388
389	RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE, RPC_BINDING_HANDLE*);
390	RPC_STATUS RpcBindingFree(RPC_BINDING_HANDLE*);
391	RPC_STATUS RpcBindingInqObject(RPC_BINDING_HANDLE, UUID*);
392	RPC_STATUS RpcBindingReset(RPC_BINDING_HANDLE);
393	RPC_STATUS RpcBindingSetObject(RPC_BINDING_HANDLE, UUID*);
394	RPC_STATUS RpcMgmtInqDefaultProtectLevel(uint, uint*);
395	RPC_STATUS RpcBindingVectorFree(RPC_BINDING_VECTOR**);
396	RPC_STATUS RpcIfInqId(RPC_IF_HANDLE, RPC_IF_ID*);
397	RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE, uint*);
398	RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE, uint);
399	RPC_STATUS RpcMgmtSetCancelTimeout(int Timeout);
400	RPC_STATUS RpcObjectInqType(UUID, UUID);
401	RPC_STATUS RpcObjectSetInqFn(RPC_OBJECT_INQ_FN*);
402	RPC_STATUS RpcObjectSetType(UUID, UUID);
403	RPC_STATUS RpcProtseqVectorFree(RPC_PROTSEQ_VECTOR**);
404	RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE, UUID, RPC_MGR_EPV*);
405	RPC_STATUS RpcServerListen(uint, uint, uint);
406	RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE, UUID, RPC_MGR_EPV);
407	RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE, UUID, RPC_MGR_EPV, uint, uint, RPC_IF_CALLBACK_FN*);
408	RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE, UUID, RPC_MGR_EPV, uint, uint, uint, RPC_IF_CALLBACK_FN*);
409	RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE, UUID*, uint);
410	RPC_STATUS RpcServerUseAllProtseqs(uint, void*);
411	RPC_STATUS RpcServerUseAllProtseqsEx(uint, void*, PRPC_POLICY);
412	RPC_STATUS RpcServerUseAllProtseqsIf(uint, RPC_IF_HANDLE, void*);
413	RPC_STATUS RpcServerUseAllProtseqsIfEx(uint, RPC_IF_HANDLE, void*, PRPC_POLICY);
414	RPC_STATUS RpcMgmtStatsVectorFree(RPC_STATS_VECTOR**);
415	RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE, RPC_STATS_VECTOR**);
416	RPC_STATUS RpcMgmtIsServerListening(RPC_BINDING_HANDLE);
417	RPC_STATUS RpcMgmtStopServerListening(RPC_BINDING_HANDLE);
418	RPC_STATUS RpcMgmtWaitServerListen();
419	RPC_STATUS RpcMgmtSetServerStackSize(uint);
420	void RpcSsDontSerializeContext();
421	RPC_STATUS RpcMgmtEnableIdleCleanup();
422	RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE, RPC_IF_ID_VECTOR**);
423	RPC_STATUS RpcIfIdVectorFree(RPC_IF_ID_VECTOR**);
424	RPC_STATUS RpcEpResolveBinding(RPC_BINDING_HANDLE, RPC_IF_HANDLE);
425	RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE, RPC_BINDING_HANDLE*);
426
427	// never returns
428	void RpcRaiseException(RPC_STATUS);
429	RPC_STATUS RpcTestCancel();
430	RPC_STATUS RpcCancelThread(void*);
431	RPC_STATUS UuidCreate(UUID*);
432	int UuidCompare(UUID, UUID, RPC_STATUS*);
433	RPC_STATUS UuidCreateNil(UUID*);
434	int UuidEqual(UUID, UUID, RPC_STATUS*);
435	ushort UuidHash(UUID, RPC_STATUS);
436	int UuidIsNil(UUID, RPC_STATUS);
437	RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE, RPC_BINDING_VECTOR, UUID_VECTOR);
438	RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE, uint, RPC_IF_ID, uint, UUID, RPC_EP_INQ_HANDLE*);
439	RPC_STATUS RpcMgmtEpEltInqDone(RPC_EP_INQ_HANDLE*);
440	RPC_STATUS RpcMgmtEpUnregister(RPC_BINDING_HANDLE, RPC_IF_ID, RPC_BINDING_HANDLE, UUID);
441	RPC_STATUS RpcMgmtSetAuthorizationFn(RPC_MGMT_AUTHORIZATION_FN);
442	RPC_STATUS RpcMgmtInqParameter(uint, uint*);
443	RPC_STATUS RpcMgmtSetParameter(uint, uint);
444	RPC_STATUS RpcMgmtBindingInqParameter(RPC_BINDING_HANDLE, uint, uint*);
445	RPC_STATUS RpcMgmtBindingSetParameter(RPC_BINDING_HANDLE, uint, uint);
446
447	static if (_WIN32_WINNT >= 0x0500) {
448	RPC_STATUS UuidCreateSequential(UUID*);
449	}

Note: See TracBrowser for help on using the browser.

bindings

root/trunk/win32/rpcdce.d

Download in other formats: