1 /*
2 * Unit test suite for rpc functions
3 *
4 * Copyright 2002 Greg Turner
5 * Copyright 2008-2009 Robert Shearman
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <stdio.h>
24
25 #define COBJMACROS
26 #include <ntstatus.h>
27 #define WIN32_NO_STATUS
28 #include "wine/test.h"
29 #include <windef.h>
30 #include <winbase.h>
31 #include <winnt.h>
32 #include <winerror.h>
33 #include <ole2.h>
34 #include <oleauto.h>
35 #include <ntsecapi.h>
36 #include <initguid.h>
37 #include <netfw.h>
38
39 #include "rpc.h"
40 #include "rpcdce.h"
41 #include "secext.h"
42
43 typedef unsigned int unsigned32;
44 typedef struct twr_t
45 {
46 unsigned32 tower_length;
47 /* [size_is] */ byte tower_octet_string[ 1 ];
48 } twr_t;
49
50 RPC_STATUS WINAPI TowerExplode(const twr_t *tower, RPC_SYNTAX_IDENTIFIER *object, RPC_SYNTAX_IDENTIFIER *syntax, char **protseq, char **endpoint, char **address);
51 RPC_STATUS WINAPI TowerConstruct(const RPC_SYNTAX_IDENTIFIER *object, const RPC_SYNTAX_IDENTIFIER *syntax, const char *protseq, const char *endpoint, const char *address, twr_t **tower);
52
53 static UUID Uuid_Table[10] = {
54 { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, /* 0 (null) */
55 { 0xdeadbeef, 0xdead, 0xbeef, {0x10, 0x21, 0x35, 0x56, 0x89, 0xa0, 0xf4, 0x8a} }, /* 1 */
56 { 0xabadfeed, 0x49ff, 0xbead, {0x8a, 0xf4, 0xa0, 0x89, 0x56, 0x35, 0x21, 0x10} }, /* 2 */
57 { 0x93da375c, 0x1324, 0x1355, {0x87, 0xff, 0x49, 0x44, 0x34, 0x44, 0x22, 0x19} }, /* 3 */
58 { 0xdeadbeef, 0xdead, 0xbeef, {0x10, 0x21, 0x35, 0x56, 0x89, 0xa0, 0xf4, 0x8b} }, /* 4 (~1) */
59 { 0x9badfeed, 0x49ff, 0xbead, {0x8a, 0xf4, 0xa0, 0x89, 0x56, 0x35, 0x21, 0x10} }, /* 5 (~2) */
60 { 0x00000000, 0x0001, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, /* 6 (~0) */
61 { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01} }, /* 7 (~0) */
62 { 0x12312312, 0x1231, 0x1231, {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xff} }, /* 8 */
63 { 0x11111111, 0x1111, 0x1111, {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11} } /* 9 */
64 };
65
66 /* index of "10" means "NULL" */
67 static BOOL Uuid_Comparison_Grid[11][11] = {
68 { TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE },
69 { FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
70 { FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
71 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
72 { FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
73 { FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE },
74 { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE },
75 { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
76 { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE },
77 { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE },
78 { TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE }
79 };
80
UuidConversionAndComparison(void)81 static void UuidConversionAndComparison(void) {
82 CHAR strx[100], x;
83 LPSTR str = strx;
84 WCHAR wstrx[100], wx;
85 LPWSTR wstr = wstrx;
86
87 UUID Uuid1, Uuid2, *PUuid1, *PUuid2;
88 RPC_STATUS rslt;
89
90 int i1,i2;
91
92 /* Uuid Equality */
93 for (i1 = 0; i1 < 11; i1++)
94 for (i2 = 0; i2 < 11; i2++) {
95 if (i1 < 10) {
96 Uuid1 = Uuid_Table[i1];
97 PUuid1 = &Uuid1;
98 } else {
99 PUuid1 = NULL;
100 }
101 if (i2 < 10) {
102 Uuid2 = Uuid_Table[i2];
103 PUuid2 = &Uuid2;
104 } else {
105 PUuid2 = NULL;
106 }
107 ok( (UuidEqual(PUuid1, PUuid2, &rslt) == Uuid_Comparison_Grid[i1][i2]), "UUID Equality\n" );
108 }
109
110 /* Uuid to String to Uuid (char) */
111 for (i1 = 0; i1 < 10; i1++) {
112 Uuid1 = Uuid_Table[i1];
113 ok( (UuidToStringA(&Uuid1, (unsigned char**)&str) == RPC_S_OK), "Simple UUID->String copy\n" );
114 ok( (UuidFromStringA((unsigned char*)str, &Uuid2) == RPC_S_OK), "Simple String->UUID copy from generated UUID String\n" );
115 ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> String -> Uuid transform\n" );
116 /* invalid uuid tests -- size of valid UUID string=36 */
117 for (i2 = 0; i2 < 36; i2++) {
118 x = str[i2];
119 str[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
120 ok( (UuidFromStringA((unsigned char*)str, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID String\n" );
121 str[i2] = x; /* change it back so remaining tests are interesting. */
122 }
123 RpcStringFreeA((unsigned char **)&str);
124 }
125
126 /* Uuid to String to Uuid (wchar) */
127 for (i1 = 0; i1 < 10; i1++) {
128 Uuid1 = Uuid_Table[i1];
129 rslt=UuidToStringW(&Uuid1, &wstr);
130 ok( (rslt == RPC_S_OK), "Simple UUID->WString copy\n" );
131 ok( (UuidFromStringW(wstr, &Uuid2) == RPC_S_OK), "Simple WString->UUID copy from generated UUID String\n" );
132 ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> WString -> Uuid transform\n" );
133 /* invalid uuid tests -- size of valid UUID string=36 */
134 for (i2 = 0; i2 < 36; i2++) {
135 wx = wstr[i2];
136 wstr[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
137 ok( (UuidFromStringW(wstr, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID WString\n" );
138 wstr[i2] = wx; /* change it back so remaining tests are interesting. */
139 }
140 RpcStringFreeW(&wstr);
141 }
142 }
143
TestDceErrorInqText(void)144 static void TestDceErrorInqText (void)
145 {
146 char bufferInvalid [1024];
147 char buffer [1024]; /* The required size is not documented but would
148 * appear to be 256.
149 */
150 DWORD dwCount;
151
152 dwCount = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
153 RPC_S_NOT_RPC_ERROR, 0, bufferInvalid, ARRAY_SIZE(bufferInvalid), NULL);
154
155 /* A random sample of DceErrorInqText */
156 /* 0 is success */
157 ok ((DceErrorInqTextA (0, (unsigned char*)buffer) == RPC_S_OK),
158 "DceErrorInqTextA(0...)\n");
159 /* A real RPC_S error */
160 ok ((DceErrorInqTextA (RPC_S_INVALID_STRING_UUID, (unsigned char*)buffer) == RPC_S_OK),
161 "DceErrorInqTextA(valid...)\n");
162
163 if (dwCount)
164 {
165 /* A message for which FormatMessage should fail
166 * which should return RPC_S_OK and the
167 * fixed "not valid" message
168 */
169 ok ((DceErrorInqTextA (35, (unsigned char*)buffer) == RPC_S_OK &&
170 strcmp (buffer, bufferInvalid) == 0),
171 "DceErrorInqTextA(unformattable...)\n");
172 /* One for which FormatMessage should succeed but
173 * DceErrorInqText should "fail"
174 * 3814 is generally quite a long message
175 */
176 ok ((DceErrorInqTextA (3814, (unsigned char*)buffer) == RPC_S_OK &&
177 strcmp (buffer, bufferInvalid) == 0),
178 "DceErrorInqTextA(deviation...)\n");
179 }
180 else
181 ok (0, "Cannot set up for DceErrorInqText\n");
182 }
183
184 static RPC_DISPATCH_FUNCTION IFoo_table[] =
185 {
186 0
187 };
188
189 static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable =
190 {
191 0,
192 IFoo_table
193 };
194
195 static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface =
196 {
197 sizeof(RPC_SERVER_INTERFACE),
198 {{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x34}},{0,0}},
199 {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
200 &IFoo_v0_0_DispatchTable,
201 0,
202 0,
203 0,
204 0,
205 0,
206 };
207
208 static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface;
209
test_rpc_ncacn_ip_tcp(void)210 static void test_rpc_ncacn_ip_tcp(void)
211 {
212 RPC_STATUS status;
213 unsigned char *binding, *principal;
214 handle_t IFoo_IfHandle;
215 ULONG level, authnsvc, authzsvc;
216 RPC_AUTH_IDENTITY_HANDLE identity;
217 static unsigned char foo[] = "foo";
218 static unsigned char ncacn_ip_tcp[] = "ncacn_ip_tcp";
219 static unsigned char address[] = "127.0.0.1";
220 static unsigned char endpoint[] = "4114";
221 static unsigned char spn[] = "principal";
222
223 status = RpcNetworkIsProtseqValidA(foo);
224 ok(status == RPC_S_INVALID_RPC_PROTSEQ, "return wrong\n");
225
226 status = RpcNetworkIsProtseqValidA(ncacn_ip_tcp);
227 ok(status == RPC_S_OK, "return wrong\n");
228
229 status = RpcMgmtStopServerListening(NULL);
230 ok(status == RPC_S_NOT_LISTENING,
231 "wrong RpcMgmtStopServerListening error (%u)\n", status);
232
233 status = RpcMgmtWaitServerListen();
234 ok(status == RPC_S_NOT_LISTENING,
235 "wrong RpcMgmtWaitServerListen error status (%u)\n", status);
236
237 status = RpcServerListen(1, 20, FALSE);
238 ok(status == RPC_S_NO_PROTSEQS_REGISTERED,
239 "wrong RpcServerListen error (%u)\n", status);
240
241 status = RpcServerUseProtseqEpA(ncacn_ip_tcp, 20, endpoint, NULL);
242 ok(status == RPC_S_OK, "RpcServerUseProtseqEp failed (%u)\n", status);
243
244 status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
245 ok(status == RPC_S_OK, "RpcServerRegisterIf failed (%u)\n", status);
246
247 status = RpcServerListen(1, 20, TRUE);
248 ok(status == RPC_S_OK, "RpcServerListen failed (%u)\n", status);
249
250 status = RpcServerListen(1, 20, TRUE);
251 ok(status == RPC_S_ALREADY_LISTENING,
252 "wrong RpcServerListen error (%u)\n", status);
253
254 status = RpcStringBindingComposeA(NULL, ncacn_ip_tcp, address,
255 endpoint, NULL, &binding);
256 ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
257
258 status = RpcBindingFromStringBindingA(binding, &IFoo_IfHandle);
259 ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n",
260 status);
261
262 status = RpcBindingSetAuthInfoA(IFoo_IfHandle, NULL, RPC_C_AUTHN_LEVEL_NONE,
263 RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
264 ok(status == RPC_S_OK, "RpcBindingSetAuthInfo failed (%u)\n", status);
265
266 status = RpcBindingInqAuthInfoA(IFoo_IfHandle, NULL, NULL, NULL, NULL, NULL);
267 ok(status == RPC_S_BINDING_HAS_NO_AUTH, "RpcBindingInqAuthInfo failed (%u)\n",
268 status);
269
270 status = RpcBindingSetAuthInfoA(IFoo_IfHandle, spn, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
271 RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
272 ok(status == RPC_S_OK, "RpcBindingSetAuthInfo failed (%u)\n", status);
273
274 level = authnsvc = authzsvc = 0;
275 principal = (unsigned char *)0xdeadbeef;
276 identity = (RPC_AUTH_IDENTITY_HANDLE *)0xdeadbeef;
277 status = RpcBindingInqAuthInfoA(IFoo_IfHandle, &principal, &level, &authnsvc,
278 &identity, &authzsvc);
279
280 ok(status == RPC_S_OK, "RpcBindingInqAuthInfo failed (%u)\n", status);
281 ok(identity == NULL, "expected NULL identity, got %p\n", identity);
282 ok(principal != (unsigned char *)0xdeadbeef, "expected valid principal, got %p\n", principal);
283 ok(level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY, "expected RPC_C_AUTHN_LEVEL_PKT_PRIVACY, got %d\n", level);
284 ok(authnsvc == RPC_C_AUTHN_WINNT, "expected RPC_C_AUTHN_WINNT, got %d\n", authnsvc);
285 todo_wine ok(authzsvc == RPC_C_AUTHZ_NAME, "expected RPC_C_AUTHZ_NAME, got %d\n", authzsvc);
286 if (status == RPC_S_OK) RpcStringFreeA(&principal);
287
288 status = RpcMgmtStopServerListening(NULL);
289 ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
290 status);
291
292 status = RpcMgmtStopServerListening(NULL);
293 ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
294 status);
295
296 status = RpcServerUnregisterIf(NULL, NULL, FALSE);
297 ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
298
299 status = RpcMgmtWaitServerListen();
300 ok(status == RPC_S_OK, "RpcMgmtWaitServerListen failed (%u)\n", status);
301
302 status = RpcStringFreeA(&binding);
303 ok(status == RPC_S_OK, "RpcStringFree failed (%u)\n", status);
304
305 status = RpcBindingFree(&IFoo_IfHandle);
306 ok(status == RPC_S_OK, "RpcBindingFree failed (%u)\n", status);
307 }
308
309 /* this is what's generated with MS/RPC - it includes an extra 2
310 * bytes in the protocol floor */
311 static const unsigned char tower_data_tcp_ip1[] =
312 {
313 0x05,0x00,0x13,0x00,0x0d,0x00,0xdb,0xf1,
314 0xa4,0x47,0xca,0x67,0x10,0xb3,0x1f,0x00,
315 0xdd,0x01,0x06,0x62,0xda,0x00,0x00,0x02,
316 0x00,0x00,0x00,0x13,0x00,0x0d,0x04,0x5d,
317 0x88,0x8a,0xeb,0x1c,0xc9,0x11,0x9f,0xe8,
318 0x08,0x00,0x2b,0x10,0x48,0x60,0x02,0x00,
319 0x02,0x00,0x00,0x00,0x01,0x00,0x0b,0x02,
320 0x00,0x00,0x00,0x01,0x00,0x07,0x02,0x00,
321 0x00,0x87,0x01,0x00,0x09,0x04,0x00,0x0a,
322 0x00,0x00,0x01,
323 };
324 /* this is the optimal data that i think should be generated */
325 static const unsigned char tower_data_tcp_ip2[] =
326 {
327 0x05,0x00,0x13,0x00,0x0d,0x00,0xdb,0xf1,
328 0xa4,0x47,0xca,0x67,0x10,0xb3,0x1f,0x00,
329 0xdd,0x01,0x06,0x62,0xda,0x00,0x00,0x02,
330 0x00,0x00,0x00,0x13,0x00,0x0d,0x04,0x5d,
331 0x88,0x8a,0xeb,0x1c,0xc9,0x11,0x9f,0xe8,
332 0x08,0x00,0x2b,0x10,0x48,0x60,0x02,0x00,
333 0x02,0x00,0x00,0x00,0x01,0x00,0x0b,0x00,
334 0x00,0x01,0x00,0x07,0x02,0x00,0x00,0x87,
335 0x01,0x00,0x09,0x04,0x00,0x0a,0x00,0x00,
336 0x01,
337 };
338
test_towers(void)339 static void test_towers(void)
340 {
341 RPC_STATUS ret;
342 twr_t *tower;
343 static const RPC_SYNTAX_IDENTIFIER mapi_if_id = { { 0xa4f1db00, 0xca47, 0x1067, { 0xb3, 0x1f, 0x00, 0xdd, 0x01, 0x06, 0x62, 0xda } }, { 0, 0 } };
344 static const RPC_SYNTAX_IDENTIFIER ndr_syntax = { { 0x8a885d04, 0x1ceb, 0x11c9, { 0x9f, 0xe8, 0x08, 0x00, 0x2b, 0x10, 0x48, 0x60 } }, { 2, 0 } };
345 RPC_SYNTAX_IDENTIFIER object, syntax;
346 char *protseq, *endpoint, *address;
347 BOOL same;
348
349 ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_ip_tcp", "135", "10.0.0.1", &tower);
350 ok(ret == RPC_S_OK ||
351 broken(ret == RPC_S_INVALID_RPC_PROTSEQ), /* Vista */
352 "TowerConstruct failed with error %d\n", ret);
353 if (ret == RPC_S_INVALID_RPC_PROTSEQ)
354 {
355 /* Windows Vista fails with this error and crashes if we continue */
356 win_skip("TowerConstruct failed, we are most likely on Windows Vista\n");
357 return;
358 }
359
360 /* first check we have the right amount of data */
361 ok(tower->tower_length == sizeof(tower_data_tcp_ip1) ||
362 tower->tower_length == sizeof(tower_data_tcp_ip2),
363 "Wrong size of tower %d\n", tower->tower_length);
364
365 /* then do a byte-by-byte comparison */
366 same = ((tower->tower_length == sizeof(tower_data_tcp_ip1)) &&
367 !memcmp(&tower->tower_octet_string, tower_data_tcp_ip1, sizeof(tower_data_tcp_ip1))) ||
368 ((tower->tower_length == sizeof(tower_data_tcp_ip2)) &&
369 !memcmp(&tower->tower_octet_string, tower_data_tcp_ip2, sizeof(tower_data_tcp_ip2)));
370
371 ok(same, "Tower data differs\n");
372 if (!same)
373 {
374 unsigned32 i;
375 for (i = 0; i < tower->tower_length; i++)
376 {
377 if (i % 8 == 0) printf(" ");
378 printf("0x%02x,", tower->tower_octet_string[i]);
379 if (i % 8 == 7) printf("\n");
380 }
381 printf("\n");
382 }
383
384 ret = TowerExplode(tower, &object, &syntax, &protseq, &endpoint, &address);
385 ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
386 ok(!memcmp(&object, &mapi_if_id, sizeof(mapi_if_id)), "object id didn't match\n");
387 ok(!memcmp(&syntax, &ndr_syntax, sizeof(syntax)), "syntax id didn't match\n");
388 ok(!strcmp(protseq, "ncacn_ip_tcp"), "protseq was \"%s\" instead of \"ncacn_ip_tcp\"\n", protseq);
389 ok(!strcmp(endpoint, "135"), "endpoint was \"%s\" instead of \"135\"\n", endpoint);
390 ok(!strcmp(address, "10.0.0.1"), "address was \"%s\" instead of \"10.0.0.1\"\n", address);
391
392 I_RpcFree(protseq);
393 I_RpcFree(endpoint);
394 I_RpcFree(address);
395
396 ret = TowerExplode(tower, NULL, NULL, NULL, NULL, NULL);
397 ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
398
399 I_RpcFree(tower);
400
401 /* test the behaviour for ip_tcp with name instead of dotted IP notation */
402 ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_ip_tcp", "135", "localhost", &tower);
403 ok(ret == RPC_S_OK, "TowerConstruct failed with error %d\n", ret);
404 ret = TowerExplode(tower, NULL, NULL, NULL, NULL, &address);
405 ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
406 ok(!strcmp(address, "0.0.0.0") ||
407 broken(!strcmp(address, "255.255.255.255")),
408 "address was \"%s\" instead of \"0.0.0.0\"\n", address);
409
410 I_RpcFree(address);
411 I_RpcFree(tower);
412
413 /* test the behaviour for np with no address */
414 ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_np", "\\pipe\\test", NULL, &tower);
415 ok(ret == RPC_S_OK, "TowerConstruct failed with error %d\n", ret);
416 ret = TowerExplode(tower, NULL, NULL, NULL, NULL, &address);
417 ok(ret == RPC_S_OK ||
418 broken(ret != RPC_S_OK), /* win2k, indeterminate */
419 "TowerExplode failed with error %d\n", ret);
420 /* Windows XP SP3 sets address to NULL */
421 ok(!address || !strcmp(address, ""), "address was \"%s\" instead of \"\" or NULL (XP SP3)\n", address);
422
423 I_RpcFree(address);
424 I_RpcFree(tower);
425 }
426
test_I_RpcMapWin32Status(void)427 static void test_I_RpcMapWin32Status(void)
428 {
429 LONG win32status;
430 RPC_STATUS rpc_status;
431 BOOL w2k3_up = FALSE;
432
433 /* Windows 2003 and above return STATUS_UNSUCCESSFUL if given an unknown status */
434 win32status = I_RpcMapWin32Status(9999);
435 if (win32status == STATUS_UNSUCCESSFUL)
436 w2k3_up = TRUE;
437
438 /* On Windows XP-SP1 and below some statuses are not mapped and return
439 * the given status
440 */
441 for (rpc_status = 0; rpc_status < 10000; rpc_status++)
442 {
443 LONG expected_win32status;
444 BOOL missing = FALSE;
445
446 win32status = I_RpcMapWin32Status(rpc_status);
447 switch (rpc_status)
448 {
449 case ERROR_SUCCESS: expected_win32status = ERROR_SUCCESS; break;
450 case ERROR_ACCESS_DENIED: expected_win32status = STATUS_ACCESS_DENIED; break;
451 case ERROR_INVALID_HANDLE: expected_win32status = RPC_NT_SS_CONTEXT_MISMATCH; break;
452 case ERROR_OUTOFMEMORY: expected_win32status = STATUS_NO_MEMORY; break;
453 case ERROR_INVALID_PARAMETER: expected_win32status = STATUS_INVALID_PARAMETER; break;
454 case ERROR_INSUFFICIENT_BUFFER: expected_win32status = STATUS_BUFFER_TOO_SMALL; break;
455 case ERROR_MAX_THRDS_REACHED: expected_win32status = STATUS_NO_MEMORY; break;
456 case ERROR_NOACCESS: expected_win32status = STATUS_ACCESS_VIOLATION; break;
457 case ERROR_NOT_ENOUGH_SERVER_MEMORY: expected_win32status = STATUS_INSUFF_SERVER_RESOURCES; break;
458 case ERROR_WRONG_PASSWORD: expected_win32status = STATUS_WRONG_PASSWORD; missing = TRUE; break;
459 case ERROR_INVALID_LOGON_HOURS: expected_win32status = STATUS_INVALID_LOGON_HOURS; missing = TRUE; break;
460 case ERROR_PASSWORD_EXPIRED: expected_win32status = STATUS_PASSWORD_EXPIRED; missing = TRUE; break;
461 case ERROR_ACCOUNT_DISABLED: expected_win32status = STATUS_ACCOUNT_DISABLED; missing = TRUE; break;
462 case ERROR_INVALID_SECURITY_DESCR: expected_win32status = STATUS_INVALID_SECURITY_DESCR; break;
463 case RPC_S_INVALID_STRING_BINDING: expected_win32status = RPC_NT_INVALID_STRING_BINDING; break;
464 case RPC_S_WRONG_KIND_OF_BINDING: expected_win32status = RPC_NT_WRONG_KIND_OF_BINDING; break;
465 case RPC_S_INVALID_BINDING: expected_win32status = RPC_NT_INVALID_BINDING; break;
466 case RPC_S_PROTSEQ_NOT_SUPPORTED: expected_win32status = RPC_NT_PROTSEQ_NOT_SUPPORTED; break;
467 case RPC_S_INVALID_RPC_PROTSEQ: expected_win32status = RPC_NT_INVALID_RPC_PROTSEQ; break;
468 case RPC_S_INVALID_STRING_UUID: expected_win32status = RPC_NT_INVALID_STRING_UUID; break;
469 case RPC_S_INVALID_ENDPOINT_FORMAT: expected_win32status = RPC_NT_INVALID_ENDPOINT_FORMAT; break;
470 case RPC_S_INVALID_NET_ADDR: expected_win32status = RPC_NT_INVALID_NET_ADDR; break;
471 case RPC_S_NO_ENDPOINT_FOUND: expected_win32status = RPC_NT_NO_ENDPOINT_FOUND; break;
472 case RPC_S_INVALID_TIMEOUT: expected_win32status = RPC_NT_INVALID_TIMEOUT; break;
473 case RPC_S_OBJECT_NOT_FOUND: expected_win32status = RPC_NT_OBJECT_NOT_FOUND; break;
474 case RPC_S_ALREADY_REGISTERED: expected_win32status = RPC_NT_ALREADY_REGISTERED; break;
475 case RPC_S_TYPE_ALREADY_REGISTERED: expected_win32status = RPC_NT_TYPE_ALREADY_REGISTERED; break;
476 case RPC_S_ALREADY_LISTENING: expected_win32status = RPC_NT_ALREADY_LISTENING; break;
477 case RPC_S_NO_PROTSEQS_REGISTERED: expected_win32status = RPC_NT_NO_PROTSEQS_REGISTERED; break;
478 case RPC_S_NOT_LISTENING: expected_win32status = RPC_NT_NOT_LISTENING; break;
479 case RPC_S_UNKNOWN_MGR_TYPE: expected_win32status = RPC_NT_UNKNOWN_MGR_TYPE; break;
480 case RPC_S_UNKNOWN_IF: expected_win32status = RPC_NT_UNKNOWN_IF; break;
481 case RPC_S_NO_BINDINGS: expected_win32status = RPC_NT_NO_BINDINGS; break;
482 case RPC_S_NO_PROTSEQS: expected_win32status = RPC_NT_NO_PROTSEQS; break;
483 case RPC_S_CANT_CREATE_ENDPOINT: expected_win32status = RPC_NT_CANT_CREATE_ENDPOINT; break;
484 case RPC_S_OUT_OF_RESOURCES: expected_win32status = RPC_NT_OUT_OF_RESOURCES; break;
485 case RPC_S_SERVER_UNAVAILABLE: expected_win32status = RPC_NT_SERVER_UNAVAILABLE; break;
486 case RPC_S_SERVER_TOO_BUSY: expected_win32status = RPC_NT_SERVER_TOO_BUSY; break;
487 case RPC_S_INVALID_NETWORK_OPTIONS: expected_win32status = RPC_NT_INVALID_NETWORK_OPTIONS; break;
488 case RPC_S_NO_CALL_ACTIVE: expected_win32status = RPC_NT_NO_CALL_ACTIVE; break;
489 case RPC_S_CALL_FAILED: expected_win32status = RPC_NT_CALL_FAILED; break;
490 case RPC_S_CALL_FAILED_DNE: expected_win32status = RPC_NT_CALL_FAILED_DNE; break;
491 case RPC_S_PROTOCOL_ERROR: expected_win32status = RPC_NT_PROTOCOL_ERROR; break;
492 case RPC_S_UNSUPPORTED_TRANS_SYN: expected_win32status = RPC_NT_UNSUPPORTED_TRANS_SYN; break;
493 case RPC_S_UNSUPPORTED_TYPE: expected_win32status = RPC_NT_UNSUPPORTED_TYPE; break;
494 case RPC_S_INVALID_TAG: expected_win32status = RPC_NT_INVALID_TAG; break;
495 case RPC_S_INVALID_BOUND: expected_win32status = RPC_NT_INVALID_BOUND; break;
496 case RPC_S_NO_ENTRY_NAME: expected_win32status = RPC_NT_NO_ENTRY_NAME; break;
497 case RPC_S_INVALID_NAME_SYNTAX: expected_win32status = RPC_NT_INVALID_NAME_SYNTAX; break;
498 case RPC_S_UNSUPPORTED_NAME_SYNTAX: expected_win32status = RPC_NT_UNSUPPORTED_NAME_SYNTAX; break;
499 case RPC_S_UUID_NO_ADDRESS: expected_win32status = RPC_NT_UUID_NO_ADDRESS; break;
500 case RPC_S_DUPLICATE_ENDPOINT: expected_win32status = RPC_NT_DUPLICATE_ENDPOINT; break;
501 case RPC_S_UNKNOWN_AUTHN_TYPE: expected_win32status = RPC_NT_UNKNOWN_AUTHN_TYPE; break;
502 case RPC_S_MAX_CALLS_TOO_SMALL: expected_win32status = RPC_NT_MAX_CALLS_TOO_SMALL; break;
503 case RPC_S_STRING_TOO_LONG: expected_win32status = RPC_NT_STRING_TOO_LONG; break;
504 case RPC_S_PROTSEQ_NOT_FOUND: expected_win32status = RPC_NT_PROTSEQ_NOT_FOUND; break;
505 case RPC_S_PROCNUM_OUT_OF_RANGE: expected_win32status = RPC_NT_PROCNUM_OUT_OF_RANGE; break;
506 case RPC_S_BINDING_HAS_NO_AUTH: expected_win32status = RPC_NT_BINDING_HAS_NO_AUTH; break;
507 case RPC_S_UNKNOWN_AUTHN_SERVICE: expected_win32status = RPC_NT_UNKNOWN_AUTHN_SERVICE; break;
508 case RPC_S_UNKNOWN_AUTHN_LEVEL: expected_win32status = RPC_NT_UNKNOWN_AUTHN_LEVEL; break;
509 case RPC_S_INVALID_AUTH_IDENTITY: expected_win32status = RPC_NT_INVALID_AUTH_IDENTITY; break;
510 case RPC_S_UNKNOWN_AUTHZ_SERVICE: expected_win32status = RPC_NT_UNKNOWN_AUTHZ_SERVICE; break;
511 case EPT_S_INVALID_ENTRY: expected_win32status = EPT_NT_INVALID_ENTRY; break;
512 case EPT_S_CANT_PERFORM_OP: expected_win32status = EPT_NT_CANT_PERFORM_OP; break;
513 case EPT_S_NOT_REGISTERED: expected_win32status = EPT_NT_NOT_REGISTERED; break;
514 case EPT_S_CANT_CREATE: expected_win32status = EPT_NT_CANT_CREATE; break;
515 case RPC_S_NOTHING_TO_EXPORT: expected_win32status = RPC_NT_NOTHING_TO_EXPORT; break;
516 case RPC_S_INCOMPLETE_NAME: expected_win32status = RPC_NT_INCOMPLETE_NAME; break;
517 case RPC_S_INVALID_VERS_OPTION: expected_win32status = RPC_NT_INVALID_VERS_OPTION; break;
518 case RPC_S_NO_MORE_MEMBERS: expected_win32status = RPC_NT_NO_MORE_MEMBERS; break;
519 case RPC_S_NOT_ALL_OBJS_UNEXPORTED: expected_win32status = RPC_NT_NOT_ALL_OBJS_UNEXPORTED; break;
520 case RPC_S_INTERFACE_NOT_FOUND: expected_win32status = RPC_NT_INTERFACE_NOT_FOUND; break;
521 case RPC_S_ENTRY_ALREADY_EXISTS: expected_win32status = RPC_NT_ENTRY_ALREADY_EXISTS; break;
522 case RPC_S_ENTRY_NOT_FOUND: expected_win32status = RPC_NT_ENTRY_NOT_FOUND; break;
523 case RPC_S_NAME_SERVICE_UNAVAILABLE: expected_win32status = RPC_NT_NAME_SERVICE_UNAVAILABLE; break;
524 case RPC_S_INVALID_NAF_ID: expected_win32status = RPC_NT_INVALID_NAF_ID; break;
525 case RPC_S_CANNOT_SUPPORT: expected_win32status = RPC_NT_CANNOT_SUPPORT; break;
526 case RPC_S_NO_CONTEXT_AVAILABLE: expected_win32status = RPC_NT_NO_CONTEXT_AVAILABLE; break;
527 case RPC_S_INTERNAL_ERROR: expected_win32status = RPC_NT_INTERNAL_ERROR; break;
528 case RPC_S_ZERO_DIVIDE: expected_win32status = RPC_NT_ZERO_DIVIDE; break;
529 case RPC_S_ADDRESS_ERROR: expected_win32status = RPC_NT_ADDRESS_ERROR; break;
530 case RPC_S_FP_DIV_ZERO: expected_win32status = RPC_NT_FP_DIV_ZERO; break;
531 case RPC_S_FP_UNDERFLOW: expected_win32status = RPC_NT_FP_UNDERFLOW; break;
532 case RPC_S_FP_OVERFLOW: expected_win32status = RPC_NT_FP_OVERFLOW; break;
533 case RPC_S_CALL_IN_PROGRESS: expected_win32status = RPC_NT_CALL_IN_PROGRESS; break;
534 case RPC_S_NO_MORE_BINDINGS: expected_win32status = RPC_NT_NO_MORE_BINDINGS; break;
535 case RPC_S_CALL_CANCELLED: expected_win32status = RPC_NT_CALL_CANCELLED; missing = TRUE; break;
536 case RPC_S_INVALID_OBJECT: expected_win32status = RPC_NT_INVALID_OBJECT; break;
537 case RPC_S_INVALID_ASYNC_HANDLE: expected_win32status = RPC_NT_INVALID_ASYNC_HANDLE; missing = TRUE; break;
538 case RPC_S_INVALID_ASYNC_CALL: expected_win32status = RPC_NT_INVALID_ASYNC_CALL; missing = TRUE; break;
539 case RPC_S_GROUP_MEMBER_NOT_FOUND: expected_win32status = RPC_NT_GROUP_MEMBER_NOT_FOUND; break;
540 case RPC_X_NO_MORE_ENTRIES: expected_win32status = RPC_NT_NO_MORE_ENTRIES; break;
541 case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: expected_win32status = RPC_NT_SS_CHAR_TRANS_OPEN_FAIL; break;
542 case RPC_X_SS_CHAR_TRANS_SHORT_FILE: expected_win32status = RPC_NT_SS_CHAR_TRANS_SHORT_FILE; break;
543 case RPC_X_SS_IN_NULL_CONTEXT: expected_win32status = RPC_NT_SS_IN_NULL_CONTEXT; break;
544 case RPC_X_SS_CONTEXT_DAMAGED: expected_win32status = RPC_NT_SS_CONTEXT_DAMAGED; break;
545 case RPC_X_SS_HANDLES_MISMATCH: expected_win32status = RPC_NT_SS_HANDLES_MISMATCH; break;
546 case RPC_X_SS_CANNOT_GET_CALL_HANDLE: expected_win32status = RPC_NT_SS_CANNOT_GET_CALL_HANDLE; break;
547 case RPC_X_NULL_REF_POINTER: expected_win32status = RPC_NT_NULL_REF_POINTER; break;
548 case RPC_X_ENUM_VALUE_OUT_OF_RANGE: expected_win32status = RPC_NT_ENUM_VALUE_OUT_OF_RANGE; break;
549 case RPC_X_BYTE_COUNT_TOO_SMALL: expected_win32status = RPC_NT_BYTE_COUNT_TOO_SMALL; break;
550 case RPC_X_BAD_STUB_DATA: expected_win32status = RPC_NT_BAD_STUB_DATA; break;
551 case RPC_X_PIPE_CLOSED: expected_win32status = RPC_NT_PIPE_CLOSED; missing = TRUE; break;
552 case RPC_X_PIPE_DISCIPLINE_ERROR: expected_win32status = RPC_NT_PIPE_DISCIPLINE_ERROR; missing = TRUE; break;
553 case RPC_X_PIPE_EMPTY: expected_win32status = RPC_NT_PIPE_EMPTY; missing = TRUE; break;
554 case ERROR_PASSWORD_MUST_CHANGE: expected_win32status = STATUS_PASSWORD_MUST_CHANGE; missing = TRUE; break;
555 case ERROR_ACCOUNT_LOCKED_OUT: expected_win32status = STATUS_ACCOUNT_LOCKED_OUT; missing = TRUE; break;
556 default:
557 if (w2k3_up)
558 expected_win32status = STATUS_UNSUCCESSFUL;
559 else
560 expected_win32status = rpc_status;
561 }
562
563 ok(win32status == expected_win32status ||
564 broken(missing && win32status == rpc_status),
565 "I_RpcMapWin32Status(%d) should have returned 0x%x instead of 0x%x%s\n",
566 rpc_status, expected_win32status, win32status,
567 broken(missing) ? " (or have returned with the given status)" : "");
568 }
569 }
570
test_RpcStringBindingParseA(void)571 static void test_RpcStringBindingParseA(void)
572 {
573 static unsigned char valid_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[endpoint=\\pipe\\test]";
574 static unsigned char valid_binding2[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[\\pipe\\test]";
575 static unsigned char invalid_uuid_binding[] = "{00000000-0000-0000-c000-000000000046}@ncacn_np:.[endpoint=\\pipe\\test]";
576 static unsigned char invalid_ep_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[endpoint=test]";
577 static unsigned char invalid_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np";
578 RPC_STATUS status;
579 unsigned char *uuid;
580 unsigned char *protseq;
581 unsigned char *network_addr;
582 unsigned char *endpoint;
583 unsigned char *options;
584
585 /* test all parameters */
586 status = RpcStringBindingParseA(valid_binding, &uuid, &protseq, &network_addr, &endpoint, &options);
587 ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
588 ok(!strcmp((char *)uuid, "00000000-0000-0000-c000-000000000046"), "uuid should have been 00000000-0000-0000-C000-000000000046 instead of %s\n", uuid);
589 ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
590 ok(!strcmp((char *)network_addr, "."), "network_addr should have been . instead of %s\n", network_addr);
591 ok(!strcmp((char *)endpoint, "pipetest"), "endpoint should have been pipetest instead of %s\n", endpoint);
592 if (options)
593 ok(!strcmp((char *)options, ""), "options should have been \"\" of \"%s\"\n", options);
594 else
595 todo_wine ok(FALSE, "options is NULL\n");
596 RpcStringFreeA(&uuid);
597 RpcStringFreeA(&protseq);
598 RpcStringFreeA(&network_addr);
599 RpcStringFreeA(&endpoint);
600 RpcStringFreeA(&options);
601
602 /* test all parameters with different type of string binding */
603 status = RpcStringBindingParseA(valid_binding2, &uuid, &protseq, &network_addr, &endpoint, &options);
604 ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
605 ok(!strcmp((char *)uuid, "00000000-0000-0000-c000-000000000046"), "uuid should have been 00000000-0000-0000-C000-000000000046 instead of %s\n", uuid);
606 ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
607 ok(!strcmp((char *)network_addr, "."), "network_addr should have been . instead of %s\n", network_addr);
608 ok(!strcmp((char *)endpoint, "pipetest"), "endpoint should have been pipetest instead of %s\n", endpoint);
609 if (options)
610 ok(!strcmp((char *)options, ""), "options should have been \"\" of \"%s\"\n", options);
611 else
612 todo_wine ok(FALSE, "options is NULL\n");
613 RpcStringFreeA(&uuid);
614 RpcStringFreeA(&protseq);
615 RpcStringFreeA(&network_addr);
616 RpcStringFreeA(&endpoint);
617 RpcStringFreeA(&options);
618
619 /* test with as many parameters NULL as possible */
620 status = RpcStringBindingParseA(valid_binding, NULL, &protseq, NULL, NULL, NULL);
621 ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
622 ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
623 RpcStringFreeA(&protseq);
624
625 /* test with invalid uuid */
626 status = RpcStringBindingParseA(invalid_uuid_binding, NULL, &protseq, NULL, NULL, NULL);
627 ok(status == RPC_S_INVALID_STRING_UUID, "RpcStringBindingParseA should have returned RPC_S_INVALID_STRING_UUID instead of %d\n", status);
628 ok(protseq == NULL, "protseq was %p instead of NULL\n", protseq);
629
630 /* test with invalid endpoint */
631 status = RpcStringBindingParseA(invalid_ep_binding, NULL, &protseq, NULL, NULL, NULL);
632 ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
633 RpcStringFreeA(&protseq);
634
635 /* test with invalid binding */
636 status = RpcStringBindingParseA(invalid_binding, &uuid, &protseq, &network_addr, &endpoint, &options);
637 ok(status == RPC_S_INVALID_STRING_BINDING, "RpcStringBindingParseA should have returned RPC_S_INVALID_STRING_BINDING instead of %d\n", status);
638 ok(uuid == NULL, "uuid was %p instead of NULL\n", uuid);
639 if (uuid)
640 RpcStringFreeA(&uuid);
641 ok(protseq == NULL, "protseq was %p instead of NULL\n", protseq);
642 ok(network_addr == NULL, "network_addr was %p instead of NULL\n", network_addr);
643 if (network_addr)
644 RpcStringFreeA(&network_addr);
645 ok(endpoint == NULL, "endpoint was %p instead of NULL\n", endpoint);
646 ok(options == NULL, "options was %p instead of NULL\n", options);
647 }
648
test_RpcExceptionFilter(const char * func_name)649 static void test_RpcExceptionFilter(const char *func_name)
650 {
651 ULONG exception;
652 int retval;
653 int (WINAPI *pRpcExceptionFilter)(ULONG) = (void *)GetProcAddress(GetModuleHandleA("rpcrt4.dll"), func_name);
654
655 if (!pRpcExceptionFilter)
656 {
657 win_skip("%s not exported\n", func_name);
658 return;
659 }
660
661 for (exception = 0; exception < STATUS_REG_NAT_CONSUMPTION; exception++)
662 {
663 /* skip over uninteresting bits of the number space */
664 if (exception == 2000) exception = 0x40000000;
665 if (exception == 0x40000005) exception = 0x80000000;
666 if (exception == 0x80000005) exception = 0xc0000000;
667
668 retval = pRpcExceptionFilter(exception);
669 switch (exception)
670 {
671 case STATUS_DATATYPE_MISALIGNMENT:
672 case STATUS_BREAKPOINT:
673 case STATUS_ACCESS_VIOLATION:
674 case STATUS_ILLEGAL_INSTRUCTION:
675 case STATUS_PRIVILEGED_INSTRUCTION:
676 case STATUS_INSTRUCTION_MISALIGNMENT:
677 case STATUS_STACK_OVERFLOW:
678 case STATUS_POSSIBLE_DEADLOCK:
679 ok(retval == EXCEPTION_CONTINUE_SEARCH, "%s(0x%x) should have returned %d instead of %d\n",
680 func_name, exception, EXCEPTION_CONTINUE_SEARCH, retval);
681 break;
682 case STATUS_GUARD_PAGE_VIOLATION:
683 case STATUS_IN_PAGE_ERROR:
684 case STATUS_HANDLE_NOT_CLOSABLE:
685 trace("%s(0x%x) returned %d\n", func_name, exception, retval);
686 break;
687 default:
688 ok(retval == EXCEPTION_EXECUTE_HANDLER, "%s(0x%x) should have returned %d instead of %d\n",
689 func_name, exception, EXCEPTION_EXECUTE_HANDLER, retval);
690 }
691 }
692 }
693
test_RpcStringBindingFromBinding(void)694 static void test_RpcStringBindingFromBinding(void)
695 {
696 static unsigned char ncacn_np[] = "ncacn_np";
697 static unsigned char address[] = ".";
698 static unsigned char endpoint[] = "\\pipe\\wine_rpc_test";
699 RPC_STATUS status;
700 handle_t handle;
701 RPC_CSTR binding;
702
703 status = RpcStringBindingComposeA(NULL, ncacn_np, address,
704 endpoint, NULL, &binding);
705 ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
706
707 status = RpcBindingFromStringBindingA(binding, &handle);
708 ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
709 RpcStringFreeA(&binding);
710
711 status = RpcBindingToStringBindingA(handle, &binding);
712 ok(status == RPC_S_OK, "RpcStringBindingFromBinding failed with error %u\n", status);
713
714 ok(!strcmp((const char *)binding, "ncacn_np:.[\\\\pipe\\\\wine_rpc_test]"),
715 "binding string didn't match what was expected: \"%s\"\n", binding);
716 RpcStringFreeA(&binding);
717
718 status = RpcBindingFree(&handle);
719 ok(status == RPC_S_OK, "RpcBindingFree failed with error %u\n", status);
720 }
721
test_UuidCreate(void)722 static void test_UuidCreate(void)
723 {
724 UUID guid;
725 BYTE version;
726
727 UuidCreate(&guid);
728 version = (guid.Data3 & 0xf000) >> 12;
729 ok(version == 4 || broken(version == 1), "unexpected version %d\n",
730 version);
731 if (version == 4)
732 {
733 static UUID v4and = { 0, 0, 0x4000, { 0x80,0,0,0,0,0,0,0 } };
734 static UUID v4or = { 0xffffffff, 0xffff, 0x4fff,
735 { 0xbf,0xff,0xff,0xff,0xff,0xff,0xff,0xff } };
736 UUID and, or;
737 RPC_STATUS rslt;
738 int i;
739
740 and = guid;
741 or = guid;
742 /* Generate a bunch of UUIDs and mask them. By the end, we expect
743 * every randomly generated bit to have been zero at least once,
744 * resulting in no bits set in the and mask except those which are not
745 * randomly generated: the version number and the topmost bits of the
746 * Data4 field (treated as big-endian.) Similarly, we expect only
747 * the bits which are not randomly set to be cleared in the or mask.
748 */
749 for (i = 0; i < 1000; i++)
750 {
751 LPBYTE src, dst;
752
753 UuidCreate(&guid);
754 for (src = (LPBYTE)&guid, dst = (LPBYTE)∧
755 src - (LPBYTE)&guid < sizeof(guid); src++, dst++)
756 *dst &= *src;
757 for (src = (LPBYTE)&guid, dst = (LPBYTE)∨
758 src - (LPBYTE)&guid < sizeof(guid); src++, dst++)
759 *dst |= *src;
760 }
761 ok(UuidEqual(&and, &v4and, &rslt),
762 "unexpected bits set in V4 UUID: %s\n", wine_dbgstr_guid(&and));
763 ok(UuidEqual(&or, &v4or, &rslt),
764 "unexpected bits set in V4 UUID: %s\n", wine_dbgstr_guid(&or));
765 }
766 else
767 {
768 /* Older versions of Windows generate V1 UUIDs. For these, there are
769 * many stable bits, including at least the MAC address if one is
770 * present. Just check that Data4[0]'s most significant bits are
771 * set as expected.
772 */
773 ok((guid.Data4[0] & 0xc0) == 0x80,
774 "unexpected value in Data4[0]: %02x\n", guid.Data4[0] & 0xc0);
775 }
776 }
777
test_UuidCreateSequential(void)778 static void test_UuidCreateSequential(void)
779 {
780 UUID guid1;
781 BYTE version;
782 RPC_STATUS (WINAPI *pUuidCreateSequential)(UUID *) = (void *)GetProcAddress(GetModuleHandleA("rpcrt4.dll"), "UuidCreateSequential");
783 RPC_STATUS (WINAPI *pI_UuidCreate)(UUID *) = (void*)GetProcAddress(GetModuleHandleA("rpcrt4.dll"), "I_UuidCreate");
784 RPC_STATUS ret;
785
786 if (!pUuidCreateSequential)
787 {
788 win_skip("UuidCreateSequential not exported\n");
789 return;
790 }
791
792 ok(pI_UuidCreate != pUuidCreateSequential, "got %p, %p\n", pI_UuidCreate, pUuidCreateSequential);
793
794 ret = pUuidCreateSequential(&guid1);
795 ok(!ret || ret == RPC_S_UUID_LOCAL_ONLY,
796 "expected RPC_S_OK or RPC_S_UUID_LOCAL_ONLY, got %08x\n", ret);
797 version = (guid1.Data3 & 0xf000) >> 12;
798 ok(version == 1, "unexpected version %d\n", version);
799 if (version == 1)
800 {
801 UUID guid2;
802
803 if (!ret)
804 {
805 /* If the call succeeded, there's a valid (non-multicast) MAC
806 * address in the uuid:
807 */
808 ok(!(guid1.Data4[2] & 0x01) || broken(guid1.Data4[2] & 0x01), /* Win 8.1 */
809 "GUID does not appear to contain a MAC address: %s\n",
810 wine_dbgstr_guid(&guid1));
811 }
812 else
813 {
814 /* Otherwise, there's a randomly generated multicast MAC address
815 * address in the uuid:
816 */
817 ok((guid1.Data4[2] & 0x01),
818 "GUID does not appear to contain a multicast MAC address: %s\n",
819 wine_dbgstr_guid(&guid1));
820 }
821 /* Generate another GUID, and make sure its MAC address matches the
822 * first.
823 */
824 ret = pUuidCreateSequential(&guid2);
825 ok(!ret || ret == RPC_S_UUID_LOCAL_ONLY,
826 "expected RPC_S_OK or RPC_S_UUID_LOCAL_ONLY, got %08x\n", ret);
827 version = (guid2.Data3 & 0xf000) >> 12;
828 ok(version == 1, "unexpected version %d\n", version);
829 ok(!memcmp(guid1.Data4, guid2.Data4, sizeof(guid2.Data4)),
830 "unexpected value in MAC address: %s\n",
831 wine_dbgstr_guid(&guid2));
832
833 /* I_UuidCreate does exactly the same */
834 pI_UuidCreate(&guid2);
835 version = (guid2.Data3 & 0xf000) >> 12;
836 ok(version == 1, "unexpected version %d\n", version);
837 ok(!memcmp(guid1.Data4, guid2.Data4, sizeof(guid2.Data4)),
838 "unexpected value in MAC address: %s\n",
839 wine_dbgstr_guid(&guid2));
840 }
841 }
842
test_RpcBindingFree(void)843 static void test_RpcBindingFree(void)
844 {
845 RPC_BINDING_HANDLE binding = NULL;
846 RPC_STATUS status;
847
848 status = RpcBindingFree(&binding);
849 ok(status == RPC_S_INVALID_BINDING,
850 "RpcBindingFree should have returned RPC_S_INVALID_BINDING instead of %d\n",
851 status);
852 }
853
test_RpcStringFree(void)854 static void test_RpcStringFree(void)
855 {
856 RPC_WSTR string = NULL;
857
858 string = HeapAlloc(GetProcessHeap(), 0, 10*sizeof(WCHAR));
859 if (string == NULL)
860 {
861 skip("Failed to allocate a string!\n");
862 return;
863 }
864
865 RpcStringFreeW(&string);
866
867 ok(string == NULL, "String is %p expected NULL!\n", string);
868 }
869
test_RpcServerInqDefaultPrincName(void)870 static void test_RpcServerInqDefaultPrincName(void)
871 {
872 RPC_STATUS ret;
873 RPC_CSTR principal, saved_principal;
874 char *username;
875 ULONG len = 0;
876
877 GetUserNameExA( NameSamCompatible, NULL, &len );
878 username = HeapAlloc( GetProcessHeap(), 0, len );
879 GetUserNameExA( NameSamCompatible, username, &len );
880
881 ret = RpcServerInqDefaultPrincNameA( 0, NULL );
882 ok( ret == RPC_S_UNKNOWN_AUTHN_SERVICE, "got %u\n", ret );
883
884 ret = RpcServerInqDefaultPrincNameA( RPC_C_AUTHN_DEFAULT, NULL );
885 ok( ret == RPC_S_UNKNOWN_AUTHN_SERVICE, "got %u\n", ret );
886
887 principal = (RPC_CSTR)0xdeadbeef;
888 ret = RpcServerInqDefaultPrincNameA( RPC_C_AUTHN_DEFAULT, &principal );
889 ok( ret == RPC_S_UNKNOWN_AUTHN_SERVICE, "got %u\n", ret );
890 ok( principal == (RPC_CSTR)0xdeadbeef, "got unexpected principal\n" );
891
892 saved_principal = (RPC_CSTR)0xdeadbeef;
893 ret = RpcServerInqDefaultPrincNameA( RPC_C_AUTHN_WINNT, &saved_principal );
894 ok( ret == RPC_S_OK, "got %u\n", ret );
895 ok( saved_principal != (RPC_CSTR)0xdeadbeef, "expected valid principal\n" );
896 ok( !strcmp( (const char *)saved_principal, username ), "got \'%s\'\n", saved_principal );
897 trace("%s\n", saved_principal);
898
899 ret = RpcServerRegisterAuthInfoA( (RPC_CSTR)"wine\\test", RPC_C_AUTHN_WINNT, NULL, NULL );
900 ok( ret == RPC_S_OK, "got %u\n", ret );
901
902 principal = (RPC_CSTR)0xdeadbeef;
903 ret = RpcServerInqDefaultPrincNameA( RPC_C_AUTHN_WINNT, &principal );
904 ok( ret == RPC_S_OK, "got %u\n", ret );
905 ok( principal != (RPC_CSTR)0xdeadbeef, "expected valid principal\n" );
906 ok( !strcmp( (const char *)principal, username ), "got \'%s\'\n", principal );
907 RpcStringFreeA( &principal );
908
909 ret = RpcServerRegisterAuthInfoA( saved_principal, RPC_C_AUTHN_WINNT, NULL, NULL );
910 ok( ret == RPC_S_OK, "got %u\n", ret );
911
912 RpcStringFreeA( &saved_principal );
913 HeapFree( GetProcessHeap(), 0, username );
914 }
915
test_RpcServerRegisterAuthInfo(void)916 static void test_RpcServerRegisterAuthInfo(void)
917 {
918 RPC_STATUS status;
919
920 status = RpcServerRegisterAuthInfoW(NULL, 600, NULL, NULL);
921 ok(status == RPC_S_UNKNOWN_AUTHN_SERVICE, "status = %x\n", status);
922 }
923
test_RpcServerUseProtseq(void)924 static void test_RpcServerUseProtseq(void)
925 {
926 RPC_STATUS status;
927 RPC_BINDING_VECTOR *bindings;
928 ULONG i;
929 ULONG binding_count_before;
930 ULONG binding_count_after1;
931 ULONG binding_count_after2;
932 ULONG endpoints_registered = 0;
933 static unsigned char iptcp[] = "ncacn_ip_tcp";
934 static unsigned char np[] = "ncacn_np";
935 static unsigned char ncalrpc[] = "ncalrpc";
936 BOOL iptcp_registered = FALSE, np_registered = FALSE, ncalrpc_registered = FALSE;
937
938 status = RpcServerInqBindings(&bindings);
939 if (status == RPC_S_NO_BINDINGS)
940 binding_count_before = 0;
941 else
942 {
943 binding_count_before = bindings->Count;
944 ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
945 for (i = 0; i < bindings->Count; i++)
946 {
947 RPC_CSTR str_bind;
948 status = RpcBindingToStringBindingA(bindings->BindingH[i], &str_bind);
949 ok(status == RPC_S_OK, "RpcBindingToStringBinding failed with status %d\n", status);
950 if (lstrlenA((const char *)str_bind) > 12 && !memcmp(str_bind, "ncacn_ip_tcp", 12))
951 iptcp_registered = TRUE;
952 if (lstrlenA((const char *)str_bind) > 8 && !memcmp(str_bind, "ncacn_np", 8))
953 np_registered = TRUE;
954 if (lstrlenA((const char *)str_bind) > 7 && !memcmp(str_bind, "ncalrpc", 7))
955 ncalrpc_registered = TRUE;
956 RpcStringFreeA(&str_bind);
957 }
958 RpcBindingVectorFree(&bindings);
959 }
960
961 /* show that RpcServerUseProtseqEp(..., NULL, ...) is the same as
962 * RpcServerUseProtseq(...) */
963 status = RpcServerUseProtseqEpA(ncalrpc, 0, NULL, NULL);
964 ok(status == RPC_S_OK || broken(status == RPC_S_INVALID_ENDPOINT_FORMAT),
965 "RpcServerUseProtseqEp with NULL endpoint failed with status %d\n",
966 status);
967
968 /* register protocol sequences without explicit endpoints */
969 status = RpcServerUseProtseqA(np, 0, NULL);
970 if (status == RPC_S_PROTSEQ_NOT_SUPPORTED)
971 win_skip("ncacn_np not supported\n");
972 else
973 ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_np) failed with status %d\n", status);
974 if (status == RPC_S_OK && !np_registered) endpoints_registered++;
975
976 status = RpcServerUseProtseqA(iptcp, 0, NULL);
977 ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_ip_tcp) failed with status %d\n", status);
978 if (status == RPC_S_OK && !iptcp_registered) endpoints_registered++;
979
980 status = RpcServerUseProtseqA(ncalrpc, 0, NULL);
981 ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", status);
982 if (status == RPC_S_OK && !ncalrpc_registered) endpoints_registered++;
983
984 status = RpcServerInqBindings(&bindings);
985 ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
986 binding_count_after1 = bindings->Count;
987 ok(binding_count_after1 == binding_count_before + endpoints_registered,
988 "wrong binding count - before: %u, after %u, endpoints registered %u\n",
989 binding_count_before, binding_count_after1, endpoints_registered);
990 for (i = 0; i < bindings->Count; i++)
991 {
992 RPC_CSTR str_bind;
993 status = RpcBindingToStringBindingA(bindings->BindingH[i], &str_bind);
994 ok(status == RPC_S_OK, "RpcBindingToStringBinding failed with status %d\n", status);
995 trace("string binding: %s\n", str_bind);
996 RpcStringFreeA(&str_bind);
997 }
998 RpcBindingVectorFree(&bindings);
999
1000 /* re-register - endpoints should be reused */
1001 status = RpcServerUseProtseqA(np, 0, NULL);
1002 if (status == RPC_S_PROTSEQ_NOT_SUPPORTED)
1003 win_skip("ncacn_np not supported\n");
1004 else
1005 ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_np) failed with status %d\n", status);
1006
1007 status = RpcServerUseProtseqA(iptcp, 0, NULL);
1008 ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_ip_tcp) failed with status %d\n", status);
1009
1010 status = RpcServerUseProtseqA(ncalrpc, 0, NULL);
1011 ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", status);
1012
1013 status = RpcServerInqBindings(&bindings);
1014 ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
1015 binding_count_after2 = bindings->Count;
1016 ok(binding_count_after2 == binding_count_after1,
1017 "bindings should have been re-used - after1: %u after2: %u\n",
1018 binding_count_after1, binding_count_after2);
1019 RpcBindingVectorFree(&bindings);
1020 }
1021
test_endpoint_mapper(RPC_CSTR protseq,RPC_CSTR address)1022 static void test_endpoint_mapper(RPC_CSTR protseq, RPC_CSTR address)
1023 {
1024 static unsigned char annotation[] = "Test annotation string.";
1025 RPC_STATUS status;
1026 RPC_BINDING_VECTOR *binding_vector;
1027 handle_t handle;
1028 unsigned char *binding;
1029
1030 status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
1031 ok(status == RPC_S_OK, "%s: RpcServerRegisterIf failed (%u)\n", protseq, status);
1032
1033 status = RpcServerInqBindings(&binding_vector);
1034 ok(status == RPC_S_OK, "%s: RpcServerInqBindings failed with error %u\n", protseq, status);
1035
1036 /* register endpoints created in test_RpcServerUseProtseq */
1037 status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, annotation);
1038 ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
1039 /* reregister the same endpoint with no annotation */
1040 status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, NULL);
1041 ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
1042
1043 status = RpcStringBindingComposeA(NULL, protseq, address,
1044 NULL, NULL, &binding);
1045 ok(status == RPC_S_OK, "%s: RpcStringBindingCompose failed (%u)\n", protseq, status);
1046
1047 status = RpcBindingFromStringBindingA(binding, &handle);
1048 ok(status == RPC_S_OK, "%s: RpcBindingFromStringBinding failed (%u)\n", protseq, status);
1049
1050 RpcStringFreeA(&binding);
1051
1052 status = RpcBindingReset(handle);
1053 ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
1054
1055 status = RpcEpResolveBinding(handle, IFoo_v0_0_s_ifspec);
1056 ok(status == RPC_S_OK || broken(status == RPC_S_SERVER_UNAVAILABLE), /* win9x */
1057 "%s: RpcEpResolveBinding failed with error %u\n", protseq, status);
1058
1059 status = RpcBindingReset(handle);
1060 ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
1061
1062 status = RpcBindingFree(&handle);
1063 ok(status == RPC_S_OK, "%s: RpcBindingFree failed with error %u\n", protseq, status);
1064
1065 status = RpcServerUnregisterIf(NULL, NULL, FALSE);
1066 ok(status == RPC_S_OK, "%s: RpcServerUnregisterIf failed (%u)\n", protseq, status);
1067
1068 status = RpcEpUnregister(IFoo_v0_0_s_ifspec, binding_vector, NULL);
1069 ok(status == RPC_S_OK, "%s: RpcEpUnregisterA failed with error %u\n", protseq, status);
1070
1071 status = RpcBindingVectorFree(&binding_vector);
1072 ok(status == RPC_S_OK, "%s: RpcBindingVectorFree failed with error %u\n", protseq, status);
1073 }
1074
is_process_elevated(void)1075 static BOOL is_process_elevated(void)
1076 {
1077 HANDLE token;
1078 if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token ))
1079 {
1080 TOKEN_ELEVATION_TYPE type;
1081 DWORD size;
1082 BOOL ret;
1083
1084 ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size );
1085 CloseHandle( token );
1086 return (ret && type == TokenElevationTypeFull);
1087 }
1088 return FALSE;
1089 }
1090
is_firewall_enabled(void)1091 static BOOL is_firewall_enabled(void)
1092 {
1093 HRESULT hr, init;
1094 INetFwMgr *mgr = NULL;
1095 INetFwPolicy *policy = NULL;
1096 INetFwProfile *profile = NULL;
1097 VARIANT_BOOL enabled = VARIANT_FALSE;
1098
1099 init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
1100
1101 hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
1102 (void **)&mgr );
1103 ok( hr == S_OK, "got %08x\n", hr );
1104 if (hr != S_OK) goto done;
1105
1106 hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
1107 ok( hr == S_OK, "got %08x\n", hr );
1108 if (hr != S_OK) goto done;
1109
1110 hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
1111 if (hr != S_OK) goto done;
1112
1113 hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
1114 ok( hr == S_OK, "got %08x\n", hr );
1115
1116 done:
1117 if (policy) INetFwPolicy_Release( policy );
1118 if (profile) INetFwProfile_Release( profile );
1119 if (mgr) INetFwMgr_Release( mgr );
1120 if (SUCCEEDED( init )) CoUninitialize();
1121 return (enabled == VARIANT_TRUE);
1122 }
1123
1124 enum firewall_op
1125 {
1126 APP_ADD,
1127 APP_REMOVE
1128 };
1129
set_firewall(enum firewall_op op)1130 static HRESULT set_firewall( enum firewall_op op )
1131 {
1132 static const WCHAR testW[] = {'r','p','c','r','t','4','_','t','e','s','t',0};
1133 HRESULT hr, init;
1134 INetFwMgr *mgr = NULL;
1135 INetFwPolicy *policy = NULL;
1136 INetFwProfile *profile = NULL;
1137 INetFwAuthorizedApplication *app = NULL;
1138 INetFwAuthorizedApplications *apps = NULL;
1139 BSTR name, image = SysAllocStringLen( NULL, MAX_PATH );
1140
1141 if (!GetModuleFileNameW( NULL, image, MAX_PATH ))
1142 {
1143 SysFreeString( image );
1144 return E_FAIL;
1145 }
1146 init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
1147
1148 hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
1149 (void **)&mgr );
1150 ok( hr == S_OK, "got %08x\n", hr );
1151 if (hr != S_OK) goto done;
1152
1153 hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
1154 ok( hr == S_OK, "got %08x\n", hr );
1155 if (hr != S_OK) goto done;
1156
1157 hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
1158 if (hr != S_OK) goto done;
1159
1160 hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
1161 ok( hr == S_OK, "got %08x\n", hr );
1162 if (hr != S_OK) goto done;
1163
1164 hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
1165 &IID_INetFwAuthorizedApplication, (void **)&app );
1166 ok( hr == S_OK, "got %08x\n", hr );
1167 if (hr != S_OK) goto done;
1168
1169 hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
1170 if (hr != S_OK) goto done;
1171
1172 name = SysAllocString( testW );
1173 hr = INetFwAuthorizedApplication_put_Name( app, name );
1174 SysFreeString( name );
1175 ok( hr == S_OK, "got %08x\n", hr );
1176 if (hr != S_OK) goto done;
1177
1178 if (op == APP_ADD)
1179 hr = INetFwAuthorizedApplications_Add( apps, app );
1180 else if (op == APP_REMOVE)
1181 hr = INetFwAuthorizedApplications_Remove( apps, image );
1182 else
1183 hr = E_INVALIDARG;
1184
1185 done:
1186 if (app) INetFwAuthorizedApplication_Release( app );
1187 if (apps) INetFwAuthorizedApplications_Release( apps );
1188 if (policy) INetFwPolicy_Release( policy );
1189 if (profile) INetFwProfile_Release( profile );
1190 if (mgr) INetFwMgr_Release( mgr );
1191 if (SUCCEEDED( init )) CoUninitialize();
1192 SysFreeString( image );
1193 return hr;
1194 }
1195
START_TEST(rpc)1196 START_TEST( rpc )
1197 {
1198 static unsigned char ncacn_np[] = "ncacn_np";
1199 static unsigned char ncalrpc[] = "ncalrpc";
1200 static unsigned char np_address[] = ".";
1201 BOOL firewall_enabled = is_firewall_enabled();
1202
1203 if (firewall_enabled && !is_process_elevated())
1204 {
1205 skip("no privileges, skipping tests to avoid firewall dialog\n");
1206 return;
1207 }
1208
1209 UuidConversionAndComparison();
1210 TestDceErrorInqText();
1211 test_towers();
1212 test_I_RpcMapWin32Status();
1213 test_RpcStringBindingParseA();
1214 test_RpcExceptionFilter("I_RpcExceptionFilter");
1215 test_RpcExceptionFilter("RpcExceptionFilter");
1216 test_RpcStringBindingFromBinding();
1217 test_UuidCreate();
1218 test_UuidCreateSequential();
1219 test_RpcBindingFree();
1220 test_RpcStringFree();
1221 test_RpcServerInqDefaultPrincName();
1222 test_RpcServerRegisterAuthInfo();
1223
1224 if (firewall_enabled)
1225 {
1226 HRESULT hr = set_firewall(APP_ADD);
1227 if (hr != S_OK)
1228 {
1229 skip("can't authorize app in firewall %08x\n", hr);
1230 return;
1231 }
1232 }
1233
1234 test_rpc_ncacn_ip_tcp();
1235 test_RpcServerUseProtseq();
1236 test_endpoint_mapper(ncacn_np, np_address);
1237 test_endpoint_mapper(ncalrpc, NULL);
1238
1239 if (firewall_enabled) set_firewall(APP_REMOVE);
1240 }
1241