rostests/winetests/rpcrt4/rpc.c

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