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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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