dlls/rpcrt4/tests/rpc.c

   1 /*
   2  * Unit test suite for rpc functions
   3  *
   4  * Copyright 2002 Greg Turner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #include <ntstatus.h>
  25 #define WIN32_NO_STATUS
  26 #include "wine/test.h"
  27 #include <windef.h>
  28 #include <winbase.h>
  29 #include <winnt.h>
  30 #include <winerror.h>
  31
  32 #include "rpc.h"
  33 #include "rpcdce.h"
  34
  35 typedef unsigned int unsigned32;
  36 typedef struct twr_t
  37     {
  38     unsigned32 tower_length;
  39     /* [size_is] */ byte tower_octet_string[ 1 ];
  40     }   twr_t;
  41
  42 RPC_STATUS WINAPI TowerExplode(const twr_t *tower, RPC_SYNTAX_IDENTIFIER *object, RPC_SYNTAX_IDENTIFIER *syntax, char **protseq, char **endpoint, char **address);
  43 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);
  44
  45 static UUID Uuid_Table[10] = {
  46   { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, /* 0 (null) */
  47   { 0xdeadbeef, 0xdead, 0xbeef, {0x10, 0x21, 0x35, 0x56, 0x89, 0xa0, 0xf4, 0x8a} }, /* 1 */
  48   { 0xabadfeed, 0x49ff, 0xbead, {0x8a, 0xf4, 0xa0, 0x89, 0x56, 0x35, 0x21, 0x10} }, /* 2 */
  49   { 0x93da375c, 0x1324, 0x1355, {0x87, 0xff, 0x49, 0x44, 0x34, 0x44, 0x22, 0x19} }, /* 3 */
  50   { 0xdeadbeef, 0xdead, 0xbeef, {0x10, 0x21, 0x35, 0x56, 0x89, 0xa0, 0xf4, 0x8b} }, /* 4 (~1) */
  51   { 0x9badfeed, 0x49ff, 0xbead, {0x8a, 0xf4, 0xa0, 0x89, 0x56, 0x35, 0x21, 0x10} }, /* 5 (~2) */
  52   { 0x00000000, 0x0001, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }, /* 6 (~0) */
  53   { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01} }, /* 7 (~0) */
  54   { 0x12312312, 0x1231, 0x1231, {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xff} }, /* 8 */
  55   { 0x11111111, 0x1111, 0x1111, {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11} }  /* 9 */
  56 };
  57
  58 /* index of "10" means "NULL" */
  59 static BOOL Uuid_Comparison_Grid[11][11] = {
  60   { TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE  },
  61   { FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
  62   { FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
  63   { FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
  64   { FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE },
  65   { FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE },
  66   { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE, FALSE },
  67   { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE, FALSE },
  68   { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE, FALSE },
  69   { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,  FALSE },
  70   { TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE  }
  71 };
  72
  73 static void UuidConversionAndComparison(void) {
  74     CHAR strx[100], x;
  75     LPSTR str = strx;
  76     WCHAR wstrx[100], wx;
  77     LPWSTR wstr = wstrx;
  78
  79     UUID Uuid1, Uuid2, *PUuid1, *PUuid2;
  80     RPC_STATUS rslt;
  81
  82     int i1,i2;
  83
  84     /* Uuid Equality */
  85     for (i1 = 0; i1 < 11; i1++)
  86         for (i2 = 0; i2 < 11; i2++) {
  87             if (i1 < 10) {
  88                 Uuid1 = Uuid_Table[i1];
  89                 PUuid1 = &Uuid1;
  90             } else {
  91                 PUuid1 = NULL;
  92             }
  93             if (i2 < 10) {
  94                 Uuid2 = Uuid_Table[i2];
  95                 PUuid2 = &Uuid2;
  96             } else {
  97                 PUuid2 = NULL;
  98             }
  99             ok( (UuidEqual(PUuid1, PUuid2, &rslt) == Uuid_Comparison_Grid[i1][i2]), "UUID Equality\n" );
 100         }
 101
 102     /* Uuid to String to Uuid (char) */
 103     for (i1 = 0; i1 < 10; i1++) {
 104         Uuid1 = Uuid_Table[i1];
 105         ok( (UuidToStringA(&Uuid1, (unsigned char**)&str) == RPC_S_OK), "Simple UUID->String copy\n" );
 106         ok( (UuidFromStringA((unsigned char*)str, &Uuid2) == RPC_S_OK), "Simple String->UUID copy from generated UUID String\n" );
 107         ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> String -> Uuid transform\n" );
 108         /* invalid uuid tests  -- size of valid UUID string=36 */
 109         for (i2 = 0; i2 < 36; i2++) {
 110             x = str[i2];
 111             str[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
 112             ok( (UuidFromStringA((unsigned char*)str, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID String\n" );
 113             str[i2] = x; /* change it back so remaining tests are interesting. */
 114         }
 115         RpcStringFree((unsigned char **)&str);
 116     }
 117
 118     /* Uuid to String to Uuid (wchar) */
 119     for (i1 = 0; i1 < 10; i1++) {
 120         Uuid1 = Uuid_Table[i1];
 121         rslt=UuidToStringW(&Uuid1, &wstr);
 122         if (rslt==RPC_S_CANNOT_SUPPORT) {
 123             /* Must be Win9x (no Unicode support), skip the tests */
 124             break;
 125         }
 126         ok( (rslt == RPC_S_OK), "Simple UUID->WString copy\n" );
 127         ok( (UuidFromStringW(wstr, &Uuid2) == RPC_S_OK), "Simple WString->UUID copy from generated UUID String\n" );
 128         ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> WString -> Uuid transform\n" );
 129         /* invalid uuid tests  -- size of valid UUID string=36 */
 130         for (i2 = 0; i2 < 36; i2++) {
 131             wx = wstr[i2];
 132             wstr[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
 133             ok( (UuidFromStringW(wstr, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID WString\n" );
 134             wstr[i2] = wx; /* change it back so remaining tests are interesting. */
 135         }
 136         RpcStringFreeW(&wstr);
 137     }
 138 }
 139
 140 static void TestDceErrorInqText (void)
 141 {
 142     char bufferInvalid [1024];
 143     char buffer [1024]; /* The required size is not documented but would
 144                          * appear to be 256.
 145                          */
 146     DWORD dwCount;
 147
 148     dwCount = FormatMessageA (FORMAT_MESSAGE_FROM_SYSTEM |
 149               FORMAT_MESSAGE_IGNORE_INSERTS,
 150               NULL, RPC_S_NOT_RPC_ERROR, 0, bufferInvalid,
 151               sizeof(bufferInvalid)/sizeof(bufferInvalid[0]), NULL);
 152
 153     /* A random sample of DceErrorInqText */
 154     /* 0 is success */
 155     ok ((DceErrorInqTextA (0, (unsigned char*)buffer) == RPC_S_OK),
 156             "DceErrorInqTextA(0...)\n");
 157     /* A real RPC_S error */
 158     ok ((DceErrorInqTextA (RPC_S_INVALID_STRING_UUID, (unsigned char*)buffer) == RPC_S_OK),
 159             "DceErrorInqTextA(valid...)\n");
 160
 161     if (dwCount)
 162     {
 163         /* A message for which FormatMessage should fail
 164          * which should return RPC_S_OK and the
 165          * fixed "not valid" message
 166          */
 167         ok ((DceErrorInqTextA (35, (unsigned char*)buffer) == RPC_S_OK &&
 168                     strcmp (buffer, bufferInvalid) == 0),
 169                 "DceErrorInqTextA(unformattable...)\n");
 170         /* One for which FormatMessage should succeed but
 171          * DceErrorInqText should "fail"
 172          * 3814 is generally quite a long message
 173          */
 174         ok ((DceErrorInqTextA (3814, (unsigned char*)buffer) == RPC_S_OK &&
 175                     strcmp (buffer, bufferInvalid) == 0),
 176                 "DceErrorInqTextA(deviation...)\n");
 177     }
 178     else
 179         ok (0, "Cannot set up for DceErrorInqText\n");
 180 }
 181
 182 static RPC_DISPATCH_FUNCTION IFoo_table[] =
 183 {
 184     0
 185 };
 186
 187 static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable =
 188 {
 189     0,
 190     IFoo_table
 191 };
 192
 193 static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface =
 194 {
 195     sizeof(RPC_SERVER_INTERFACE),
 196     {{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x34}},{0,0}},
 197     {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
 198     &IFoo_v0_0_DispatchTable,
 199     0,
 200     0,
 201     0,
 202     0,
 203     0,
 204 };
 205
 206 static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface;
 207
 208 static void test_rpc_ncacn_ip_tcp(void)
 209 {
 210     RPC_STATUS status;
 211     unsigned char *binding, *principal;
 212     handle_t IFoo_IfHandle;
 213     ULONG level, authnsvc, authzsvc;
 214     RPC_AUTH_IDENTITY_HANDLE identity;
 215     static unsigned char foo[] = "foo";
 216     static unsigned char ncacn_ip_tcp[] = "ncacn_ip_tcp";
 217     static unsigned char address[] = "127.0.0.1";
 218     static unsigned char endpoint[] = "4114";
 219     static unsigned char spn[] = "principal";
 220
 221     status = RpcNetworkIsProtseqValid(foo);
 222     ok(status == RPC_S_INVALID_RPC_PROTSEQ, "return wrong\n");
 223
 224     status = RpcNetworkIsProtseqValid(ncacn_ip_tcp);
 225     ok(status == RPC_S_OK, "return wrong\n");
 226
 227     status = RpcMgmtStopServerListening(NULL);
 228 todo_wine {
 229     ok(status == RPC_S_NOT_LISTENING,
 230        "wrong RpcMgmtStopServerListening error (%u)\n", status);
 231 }
 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 = RpcServerUseProtseqEp(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 todo_wine {
 249     ok(status == RPC_S_OK, "RpcServerListen failed (%u)\n", status);
 250 }
 251
 252     status = RpcServerListen(1, 20, TRUE);
 253 todo_wine {
 254     ok(status == RPC_S_ALREADY_LISTENING,
 255        "wrong RpcServerListen error (%u)\n", status);
 256 }
 257
 258     status = RpcStringBindingCompose(NULL, ncacn_ip_tcp, address,
 259                                      endpoint, NULL, &binding);
 260     ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
 261
 262     status = RpcBindingFromStringBinding(binding, &IFoo_IfHandle);
 263     ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n",
 264        status);
 265
 266     status = RpcBindingSetAuthInfo(IFoo_IfHandle, NULL, RPC_C_AUTHN_LEVEL_NONE,
 267                                    RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
 268     ok(status == RPC_S_OK || broken(status == RPC_S_UNKNOWN_AUTHN_SERVICE), /* win9x */
 269        "RpcBindingSetAuthInfo failed (%u)\n", status);
 270
 271     status = RpcBindingInqAuthInfo(IFoo_IfHandle, NULL, NULL, NULL, NULL, NULL);
 272     ok(status == RPC_S_BINDING_HAS_NO_AUTH, "RpcBindingInqAuthInfo failed (%u)\n",
 273        status);
 274
 275     status = RpcBindingSetAuthInfo(IFoo_IfHandle, spn, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
 276                                    RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
 277     ok(status == RPC_S_OK, "RpcBindingSetAuthInfo failed (%u)\n", status);
 278
 279     level = authnsvc = authzsvc = 0;
 280     principal = (unsigned char *)0xdeadbeef;
 281     identity = (RPC_AUTH_IDENTITY_HANDLE *)0xdeadbeef;
 282     status = RpcBindingInqAuthInfo(IFoo_IfHandle, &principal, &level, &authnsvc,
 283                                    &identity, &authzsvc);
 284
 285     ok(status == RPC_S_OK, "RpcBindingInqAuthInfo failed (%u)\n", status);
 286     ok(identity == NULL, "expected NULL identity\n");
 287     ok(principal != (unsigned char *)0xdeadbeef, "expected valid principal\n");
 288     ok(level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY, "expected RPC_C_AUTHN_LEVEL_PKT_PRIVACY\n");
 289     ok(authnsvc == RPC_C_AUTHN_WINNT, "expected RPC_C_AUTHN_WINNT\n");
 290     todo_wine ok(authzsvc == RPC_C_AUTHZ_NAME, "expected RPC_C_AUTHZ_NAME\n");
 291
 292     RpcStringFree(&principal);
 293
 294     status = RpcMgmtStopServerListening(NULL);
 295     ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
 296        status);
 297
 298     status = RpcMgmtStopServerListening(NULL);
 299     ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
 300        status);
 301
 302     status = RpcServerUnregisterIf(NULL, NULL, FALSE);
 303     ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
 304
 305     status = RpcMgmtWaitServerListen();
 306 todo_wine {
 307     ok(status == RPC_S_OK, "RpcMgmtWaitServerListen failed (%u)\n", status);
 308 }
 309
 310     status = RpcStringFree(&binding);
 311     ok(status == RPC_S_OK, "RpcStringFree failed (%u)\n", status);
 312
 313     status = RpcBindingFree(&IFoo_IfHandle);
 314     ok(status == RPC_S_OK, "RpcBindingFree failed (%u)\n", status);
 315 }
 316
 317 /* this is what's generated with MS/RPC - it includes an extra 2
 318  * bytes in the protocol floor */
 319 static const unsigned char tower_data_tcp_ip1[] =
 320 {
 321     0x05,0x00,0x13,0x00,0x0d,0x00,0xdb,0xf1,
 322     0xa4,0x47,0xca,0x67,0x10,0xb3,0x1f,0x00,
 323     0xdd,0x01,0x06,0x62,0xda,0x00,0x00,0x02,
 324     0x00,0x00,0x00,0x13,0x00,0x0d,0x04,0x5d,
 325     0x88,0x8a,0xeb,0x1c,0xc9,0x11,0x9f,0xe8,
 326     0x08,0x00,0x2b,0x10,0x48,0x60,0x02,0x00,
 327     0x02,0x00,0x00,0x00,0x01,0x00,0x0b,0x02,
 328     0x00,0x00,0x00,0x01,0x00,0x07,0x02,0x00,
 329     0x00,0x87,0x01,0x00,0x09,0x04,0x00,0x0a,
 330     0x00,0x00,0x01,
 331 };
 332 /* this is the optimal data that i think should be generated */
 333 static const unsigned char tower_data_tcp_ip2[] =
 334 {
 335     0x05,0x00,0x13,0x00,0x0d,0x00,0xdb,0xf1,
 336     0xa4,0x47,0xca,0x67,0x10,0xb3,0x1f,0x00,
 337     0xdd,0x01,0x06,0x62,0xda,0x00,0x00,0x02,
 338     0x00,0x00,0x00,0x13,0x00,0x0d,0x04,0x5d,
 339     0x88,0x8a,0xeb,0x1c,0xc9,0x11,0x9f,0xe8,
 340     0x08,0x00,0x2b,0x10,0x48,0x60,0x02,0x00,
 341     0x02,0x00,0x00,0x00,0x01,0x00,0x0b,0x00,
 342     0x00,0x01,0x00,0x07,0x02,0x00,0x00,0x87,
 343     0x01,0x00,0x09,0x04,0x00,0x0a,0x00,0x00,
 344     0x01,
 345 };
 346
 347 static void test_towers(void)
 348 {
 349     RPC_STATUS ret;
 350     twr_t *tower;
 351     static const RPC_SYNTAX_IDENTIFIER mapi_if_id = { { 0xa4f1db00, 0xca47, 0x1067, { 0xb3, 0x1f, 0x00, 0xdd, 0x01, 0x06, 0x62, 0xda } }, { 0, 0 } };
 352     static const RPC_SYNTAX_IDENTIFIER ndr_syntax = { { 0x8a885d04, 0x1ceb, 0x11c9, { 0x9f, 0xe8, 0x08, 0x00, 0x2b, 0x10, 0x48, 0x60 } }, { 2, 0 } };
 353     RPC_SYNTAX_IDENTIFIER object, syntax;
 354     char *protseq, *endpoint, *address;
 355     BOOL same;
 356
 357     ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_ip_tcp", "135", "10.0.0.1", &tower);
 358     ok(ret == RPC_S_OK ||
 359        broken(ret == RPC_S_INVALID_RPC_PROTSEQ), /* Vista */
 360        "TowerConstruct failed with error %d\n", ret);
 361     if (ret == RPC_S_INVALID_RPC_PROTSEQ)
 362     {
 363         /* Windows Vista fails with this error and crashes if we continue */
 364         win_skip("TowerConstruct failed, we are most likely on Windows Vista\n");
 365         return;
 366     }
 367
 368     /* first check we have the right amount of data */
 369     ok(tower->tower_length == sizeof(tower_data_tcp_ip1) ||
 370        tower->tower_length == sizeof(tower_data_tcp_ip2),
 371         "Wrong size of tower %d\n", tower->tower_length);
 372
 373     /* then do a byte-by-byte comparison */
 374     same = ((tower->tower_length == sizeof(tower_data_tcp_ip1)) &&
 375             !memcmp(&tower->tower_octet_string, tower_data_tcp_ip1, sizeof(tower_data_tcp_ip1))) ||
 376            ((tower->tower_length == sizeof(tower_data_tcp_ip2)) &&
 377             !memcmp(&tower->tower_octet_string, tower_data_tcp_ip2, sizeof(tower_data_tcp_ip2)));
 378
 379     ok(same, "Tower data differs\n");
 380     if (!same)
 381     {
 382         unsigned32 i;
 383         for (i = 0; i < tower->tower_length; i++)
 384         {
 385             if (i % 8 == 0) printf("    ");
 386             printf("0x%02x,", tower->tower_octet_string[i]);
 387             if (i % 8 == 7) printf("\n");
 388         }
 389         printf("\n");
 390     }
 391
 392     ret = TowerExplode(tower, &object, &syntax, &protseq, &endpoint, &address);
 393     ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
 394     ok(!memcmp(&object, &mapi_if_id, sizeof(mapi_if_id)), "object id didn't match\n");
 395     ok(!memcmp(&syntax, &ndr_syntax, sizeof(syntax)), "syntax id didn't match\n");
 396     ok(!strcmp(protseq, "ncacn_ip_tcp"), "protseq was \"%s\" instead of \"ncacn_ip_tcp\"\n", protseq);
 397     ok(!strcmp(endpoint, "135"), "endpoint was \"%s\" instead of \"135\"\n", endpoint);
 398     ok(!strcmp(address, "10.0.0.1"), "address was \"%s\" instead of \"10.0.0.1\"\n", address);
 399
 400     I_RpcFree(protseq);
 401     I_RpcFree(endpoint);
 402     I_RpcFree(address);
 403
 404     ret = TowerExplode(tower, NULL, NULL, NULL, NULL, NULL);
 405     ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
 406
 407     I_RpcFree(tower);
 408
 409     /* test the behaviour for ip_tcp with name instead of dotted IP notation */
 410     ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_ip_tcp", "135", "localhost", &tower);
 411     ok(ret == RPC_S_OK, "TowerConstruct failed with error %d\n", ret);
 412     ret = TowerExplode(tower, NULL, NULL, NULL, NULL, &address);
 413     ok(ret == RPC_S_OK, "TowerExplode failed with error %d\n", ret);
 414     ok(!strcmp(address, "0.0.0.0") ||
 415        broken(!strcmp(address, "255.255.255.255")),
 416        "address was \"%s\" instead of \"0.0.0.0\"\n", address);
 417
 418     I_RpcFree(address);
 419     I_RpcFree(tower);
 420
 421     /* test the behaviour for np with no address */
 422     ret = TowerConstruct(&mapi_if_id, &ndr_syntax, "ncacn_np", "\\pipe\\test", NULL, &tower);
 423     ok(ret == RPC_S_OK, "TowerConstruct failed with error %d\n", ret);
 424     ret = TowerExplode(tower, NULL, NULL, NULL, NULL, &address);
 425     ok(ret == RPC_S_OK ||
 426        broken(ret != RPC_S_OK), /* win2k, indeterminate */
 427        "TowerExplode failed with error %d\n", ret);
 428     /* Windows XP SP3 sets address to NULL */
 429     ok(!address || !strcmp(address, ""), "address was \"%s\" instead of \"\" or NULL (XP SP3)\n", address);
 430
 431     I_RpcFree(address);
 432     I_RpcFree(tower);
 433 }
 434
 435 static void test_I_RpcMapWin32Status(void)
 436 {
 437     LONG win32status;
 438     RPC_STATUS rpc_status;
 439     BOOL on_win9x = FALSE;
 440     BOOL w2k3_up = FALSE;
 441
 442     /* Win9x always returns the given status */
 443     win32status = I_RpcMapWin32Status(ERROR_ACCESS_DENIED);
 444     if (win32status == ERROR_ACCESS_DENIED)
 445         on_win9x = TRUE;
 446
 447     /* Windows 2003 and Vista return STATUS_UNSUCCESSFUL if given an unknown status */
 448     win32status = I_RpcMapWin32Status(9999);
 449     if (win32status == STATUS_UNSUCCESSFUL)
 450     {
 451         trace("We are on Windows 2003 or Vista\n");
 452         w2k3_up = TRUE;
 453     }
 454
 455     /* On Windows XP-SP1 and below some statuses are not mapped and return
 456      * the given status
 457      */
 458     for (rpc_status = 0; rpc_status < 10000; rpc_status++)
 459     {
 460         LONG expected_win32status;
 461         BOOL missing = FALSE;
 462
 463         win32status = I_RpcMapWin32Status(rpc_status);
 464         switch (rpc_status)
 465         {
 466         case ERROR_SUCCESS: expected_win32status = ERROR_SUCCESS; break;
 467         case ERROR_ACCESS_DENIED: expected_win32status = STATUS_ACCESS_DENIED; break;
 468         case ERROR_INVALID_HANDLE: expected_win32status = RPC_NT_SS_CONTEXT_MISMATCH; break;
 469         case ERROR_OUTOFMEMORY: expected_win32status = STATUS_NO_MEMORY; break;
 470         case ERROR_INVALID_PARAMETER: expected_win32status = STATUS_INVALID_PARAMETER; break;
 471         case ERROR_INSUFFICIENT_BUFFER: expected_win32status = STATUS_BUFFER_TOO_SMALL; break;
 472         case ERROR_MAX_THRDS_REACHED: expected_win32status = STATUS_NO_MEMORY; break;
 473         case ERROR_NOACCESS: expected_win32status = STATUS_ACCESS_VIOLATION; break;
 474         case ERROR_NOT_ENOUGH_SERVER_MEMORY: expected_win32status = STATUS_INSUFF_SERVER_RESOURCES; break;
 475         case ERROR_WRONG_PASSWORD:  expected_win32status = STATUS_WRONG_PASSWORD; missing = TRUE; break;
 476         case ERROR_INVALID_LOGON_HOURS: expected_win32status = STATUS_INVALID_LOGON_HOURS; missing = TRUE; break;
 477         case ERROR_PASSWORD_EXPIRED: expected_win32status = STATUS_PASSWORD_EXPIRED; missing = TRUE; break;
 478         case ERROR_ACCOUNT_DISABLED: expected_win32status = STATUS_ACCOUNT_DISABLED; missing = TRUE; break;
 479         case ERROR_INVALID_SECURITY_DESCR: expected_win32status = STATUS_INVALID_SECURITY_DESCR; break;
 480         case RPC_S_INVALID_STRING_BINDING: expected_win32status = RPC_NT_INVALID_STRING_BINDING; break;
 481         case RPC_S_WRONG_KIND_OF_BINDING: expected_win32status = RPC_NT_WRONG_KIND_OF_BINDING; break;
 482         case RPC_S_INVALID_BINDING: expected_win32status = RPC_NT_INVALID_BINDING; break;
 483         case RPC_S_PROTSEQ_NOT_SUPPORTED: expected_win32status = RPC_NT_PROTSEQ_NOT_SUPPORTED; break;
 484         case RPC_S_INVALID_RPC_PROTSEQ: expected_win32status = RPC_NT_INVALID_RPC_PROTSEQ; break;
 485         case RPC_S_INVALID_STRING_UUID: expected_win32status = RPC_NT_INVALID_STRING_UUID; break;
 486         case RPC_S_INVALID_ENDPOINT_FORMAT: expected_win32status = RPC_NT_INVALID_ENDPOINT_FORMAT; break;
 487         case RPC_S_INVALID_NET_ADDR: expected_win32status = RPC_NT_INVALID_NET_ADDR; break;
 488         case RPC_S_NO_ENDPOINT_FOUND: expected_win32status = RPC_NT_NO_ENDPOINT_FOUND; break;
 489         case RPC_S_INVALID_TIMEOUT: expected_win32status = RPC_NT_INVALID_TIMEOUT; break;
 490         case RPC_S_OBJECT_NOT_FOUND: expected_win32status = RPC_NT_OBJECT_NOT_FOUND; break;
 491         case RPC_S_ALREADY_REGISTERED: expected_win32status = RPC_NT_ALREADY_REGISTERED; break;
 492         case RPC_S_TYPE_ALREADY_REGISTERED: expected_win32status = RPC_NT_TYPE_ALREADY_REGISTERED; break;
 493         case RPC_S_ALREADY_LISTENING: expected_win32status = RPC_NT_ALREADY_LISTENING; break;
 494         case RPC_S_NO_PROTSEQS_REGISTERED: expected_win32status = RPC_NT_NO_PROTSEQS_REGISTERED; break;
 495         case RPC_S_NOT_LISTENING: expected_win32status = RPC_NT_NOT_LISTENING; break;
 496         case RPC_S_UNKNOWN_MGR_TYPE: expected_win32status = RPC_NT_UNKNOWN_MGR_TYPE; break;
 497         case RPC_S_UNKNOWN_IF: expected_win32status = RPC_NT_UNKNOWN_IF; break;
 498         case RPC_S_NO_BINDINGS: expected_win32status = RPC_NT_NO_BINDINGS; break;
 499         case RPC_S_NO_PROTSEQS: expected_win32status = RPC_NT_NO_PROTSEQS; break;
 500         case RPC_S_CANT_CREATE_ENDPOINT: expected_win32status = RPC_NT_CANT_CREATE_ENDPOINT; break;
 501         case RPC_S_OUT_OF_RESOURCES: expected_win32status = RPC_NT_OUT_OF_RESOURCES; break;
 502         case RPC_S_SERVER_UNAVAILABLE: expected_win32status = RPC_NT_SERVER_UNAVAILABLE; break;
 503         case RPC_S_SERVER_TOO_BUSY: expected_win32status = RPC_NT_SERVER_TOO_BUSY; break;
 504         case RPC_S_INVALID_NETWORK_OPTIONS: expected_win32status = RPC_NT_INVALID_NETWORK_OPTIONS; break;
 505         case RPC_S_NO_CALL_ACTIVE: expected_win32status = RPC_NT_NO_CALL_ACTIVE; break;
 506         case RPC_S_CALL_FAILED: expected_win32status = RPC_NT_CALL_FAILED; break;
 507         case RPC_S_CALL_FAILED_DNE: expected_win32status = RPC_NT_CALL_FAILED_DNE; break;
 508         case RPC_S_PROTOCOL_ERROR: expected_win32status = RPC_NT_PROTOCOL_ERROR; break;
 509         case RPC_S_UNSUPPORTED_TRANS_SYN: expected_win32status = RPC_NT_UNSUPPORTED_TRANS_SYN; break;
 510         case RPC_S_UNSUPPORTED_TYPE: expected_win32status = RPC_NT_UNSUPPORTED_TYPE; break;
 511         case RPC_S_INVALID_TAG: expected_win32status = RPC_NT_INVALID_TAG; break;
 512         case RPC_S_INVALID_BOUND: expected_win32status = RPC_NT_INVALID_BOUND; break;
 513         case RPC_S_NO_ENTRY_NAME: expected_win32status = RPC_NT_NO_ENTRY_NAME; break;
 514         case RPC_S_INVALID_NAME_SYNTAX: expected_win32status = RPC_NT_INVALID_NAME_SYNTAX; break;
 515         case RPC_S_UNSUPPORTED_NAME_SYNTAX: expected_win32status = RPC_NT_UNSUPPORTED_NAME_SYNTAX; break;
 516         case RPC_S_UUID_NO_ADDRESS: expected_win32status = RPC_NT_UUID_NO_ADDRESS; break;
 517         case RPC_S_DUPLICATE_ENDPOINT: expected_win32status = RPC_NT_DUPLICATE_ENDPOINT; break;
 518         case RPC_S_UNKNOWN_AUTHN_TYPE: expected_win32status = RPC_NT_UNKNOWN_AUTHN_TYPE; break;
 519         case RPC_S_MAX_CALLS_TOO_SMALL: expected_win32status = RPC_NT_MAX_CALLS_TOO_SMALL; break;
 520         case RPC_S_STRING_TOO_LONG: expected_win32status = RPC_NT_STRING_TOO_LONG; break;
 521         case RPC_S_PROTSEQ_NOT_FOUND: expected_win32status = RPC_NT_PROTSEQ_NOT_FOUND; break;
 522         case RPC_S_PROCNUM_OUT_OF_RANGE: expected_win32status = RPC_NT_PROCNUM_OUT_OF_RANGE; break;
 523         case RPC_S_BINDING_HAS_NO_AUTH: expected_win32status = RPC_NT_BINDING_HAS_NO_AUTH; break;
 524         case RPC_S_UNKNOWN_AUTHN_SERVICE: expected_win32status = RPC_NT_UNKNOWN_AUTHN_SERVICE; break;
 525         case RPC_S_UNKNOWN_AUTHN_LEVEL: expected_win32status = RPC_NT_UNKNOWN_AUTHN_LEVEL; break;
 526         case RPC_S_INVALID_AUTH_IDENTITY: expected_win32status = RPC_NT_INVALID_AUTH_IDENTITY; break;
 527         case RPC_S_UNKNOWN_AUTHZ_SERVICE: expected_win32status = RPC_NT_UNKNOWN_AUTHZ_SERVICE; break;
 528         case EPT_S_INVALID_ENTRY: expected_win32status = EPT_NT_INVALID_ENTRY; break;
 529         case EPT_S_CANT_PERFORM_OP: expected_win32status = EPT_NT_CANT_PERFORM_OP; break;
 530         case EPT_S_NOT_REGISTERED: expected_win32status = EPT_NT_NOT_REGISTERED; break;
 531         case EPT_S_CANT_CREATE: expected_win32status = EPT_NT_CANT_CREATE; break;
 532         case RPC_S_NOTHING_TO_EXPORT: expected_win32status = RPC_NT_NOTHING_TO_EXPORT; break;
 533         case RPC_S_INCOMPLETE_NAME: expected_win32status = RPC_NT_INCOMPLETE_NAME; break;
 534         case RPC_S_INVALID_VERS_OPTION: expected_win32status = RPC_NT_INVALID_VERS_OPTION; break;
 535         case RPC_S_NO_MORE_MEMBERS: expected_win32status = RPC_NT_NO_MORE_MEMBERS; break;
 536         case RPC_S_NOT_ALL_OBJS_UNEXPORTED: expected_win32status = RPC_NT_NOT_ALL_OBJS_UNEXPORTED; break;
 537         case RPC_S_INTERFACE_NOT_FOUND: expected_win32status = RPC_NT_INTERFACE_NOT_FOUND; break;
 538         case RPC_S_ENTRY_ALREADY_EXISTS: expected_win32status = RPC_NT_ENTRY_ALREADY_EXISTS; break;
 539         case RPC_S_ENTRY_NOT_FOUND: expected_win32status = RPC_NT_ENTRY_NOT_FOUND; break;
 540         case RPC_S_NAME_SERVICE_UNAVAILABLE: expected_win32status = RPC_NT_NAME_SERVICE_UNAVAILABLE; break;
 541         case RPC_S_INVALID_NAF_ID: expected_win32status = RPC_NT_INVALID_NAF_ID; break;
 542         case RPC_S_CANNOT_SUPPORT: expected_win32status = RPC_NT_CANNOT_SUPPORT; break;
 543         case RPC_S_NO_CONTEXT_AVAILABLE: expected_win32status = RPC_NT_NO_CONTEXT_AVAILABLE; break;
 544         case RPC_S_INTERNAL_ERROR: expected_win32status = RPC_NT_INTERNAL_ERROR; break;
 545         case RPC_S_ZERO_DIVIDE: expected_win32status = RPC_NT_ZERO_DIVIDE; break;
 546         case RPC_S_ADDRESS_ERROR: expected_win32status = RPC_NT_ADDRESS_ERROR; break;
 547         case RPC_S_FP_DIV_ZERO: expected_win32status = RPC_NT_FP_DIV_ZERO; break;
 548         case RPC_S_FP_UNDERFLOW: expected_win32status = RPC_NT_FP_UNDERFLOW; break;
 549         case RPC_S_FP_OVERFLOW: expected_win32status = RPC_NT_FP_OVERFLOW; break;
 550         case RPC_S_CALL_IN_PROGRESS: expected_win32status = RPC_NT_CALL_IN_PROGRESS; break;
 551         case RPC_S_NO_MORE_BINDINGS: expected_win32status = RPC_NT_NO_MORE_BINDINGS; break;
 552         case RPC_S_CALL_CANCELLED: expected_win32status = RPC_NT_CALL_CANCELLED; missing = TRUE; break;
 553         case RPC_S_INVALID_OBJECT: expected_win32status = RPC_NT_INVALID_OBJECT; break;
 554         case RPC_S_INVALID_ASYNC_HANDLE: expected_win32status = RPC_NT_INVALID_ASYNC_HANDLE; missing = TRUE; break;
 555         case RPC_S_INVALID_ASYNC_CALL: expected_win32status = RPC_NT_INVALID_ASYNC_CALL; missing = TRUE; break;
 556         case RPC_S_GROUP_MEMBER_NOT_FOUND: expected_win32status = RPC_NT_GROUP_MEMBER_NOT_FOUND; break;
 557         case RPC_X_NO_MORE_ENTRIES: expected_win32status = RPC_NT_NO_MORE_ENTRIES; break;
 558         case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: expected_win32status = RPC_NT_SS_CHAR_TRANS_OPEN_FAIL; break;
 559         case RPC_X_SS_CHAR_TRANS_SHORT_FILE: expected_win32status = RPC_NT_SS_CHAR_TRANS_SHORT_FILE; break;
 560         case RPC_X_SS_IN_NULL_CONTEXT: expected_win32status = RPC_NT_SS_IN_NULL_CONTEXT; break;
 561         case RPC_X_SS_CONTEXT_DAMAGED: expected_win32status = RPC_NT_SS_CONTEXT_DAMAGED; break;
 562         case RPC_X_SS_HANDLES_MISMATCH: expected_win32status = RPC_NT_SS_HANDLES_MISMATCH; break;
 563         case RPC_X_SS_CANNOT_GET_CALL_HANDLE: expected_win32status = RPC_NT_SS_CANNOT_GET_CALL_HANDLE; break;
 564         case RPC_X_NULL_REF_POINTER: expected_win32status = RPC_NT_NULL_REF_POINTER; break;
 565         case RPC_X_ENUM_VALUE_OUT_OF_RANGE: expected_win32status = RPC_NT_ENUM_VALUE_OUT_OF_RANGE; break;
 566         case RPC_X_BYTE_COUNT_TOO_SMALL: expected_win32status = RPC_NT_BYTE_COUNT_TOO_SMALL; break;
 567         case RPC_X_BAD_STUB_DATA: expected_win32status = RPC_NT_BAD_STUB_DATA; break;
 568         case RPC_X_PIPE_CLOSED: expected_win32status = RPC_NT_PIPE_CLOSED; missing = TRUE; break;
 569         case RPC_X_PIPE_DISCIPLINE_ERROR: expected_win32status = RPC_NT_PIPE_DISCIPLINE_ERROR; missing = TRUE; break;
 570         case RPC_X_PIPE_EMPTY: expected_win32status = RPC_NT_PIPE_EMPTY; missing = TRUE; break;
 571         case ERROR_PASSWORD_MUST_CHANGE: expected_win32status = STATUS_PASSWORD_MUST_CHANGE; missing = TRUE; break;
 572         case ERROR_ACCOUNT_LOCKED_OUT: expected_win32status = STATUS_ACCOUNT_LOCKED_OUT; missing = TRUE; break;
 573         default:
 574             if (w2k3_up)
 575                 expected_win32status = STATUS_UNSUCCESSFUL;
 576             else
 577                 expected_win32status = rpc_status;
 578         }
 579
 580         if (on_win9x)
 581             missing = TRUE;
 582
 583         ok(win32status == expected_win32status ||
 584             broken(missing && win32status == rpc_status),
 585             "I_RpcMapWin32Status(%d) should have returned 0x%x instead of 0x%x%s\n",
 586             rpc_status, expected_win32status, win32status,
 587             broken(missing) ? " (or have returned with the given status)" : "");
 588     }
 589 }
 590
 591 static void test_RpcStringBindingParseA(void)
 592 {
 593     static unsigned char valid_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[endpoint=\\pipe\\test]";
 594     static unsigned char valid_binding2[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[\\pipe\\test]";
 595     static unsigned char invalid_uuid_binding[] = "{00000000-0000-0000-c000-000000000046}@ncacn_np:.[endpoint=\\pipe\\test]";
 596     static unsigned char invalid_ep_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np:.[endpoint=test]";
 597     static unsigned char invalid_binding[] = "00000000-0000-0000-c000-000000000046@ncacn_np";
 598     RPC_STATUS status;
 599     unsigned char *uuid;
 600     unsigned char *protseq;
 601     unsigned char *network_addr;
 602     unsigned char *endpoint;
 603     unsigned char *options;
 604
 605     /* test all parameters */
 606     status = RpcStringBindingParseA(valid_binding, &uuid, &protseq, &network_addr, &endpoint, &options);
 607     ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
 608     ok(!strcmp((char *)uuid, "00000000-0000-0000-c000-000000000046"), "uuid should have been 00000000-0000-0000-C000-000000000046 instead of %s\n", uuid);
 609     ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
 610     ok(!strcmp((char *)network_addr, "."), "network_addr should have been . instead of %s\n", network_addr);
 611     ok(!strcmp((char *)endpoint, "pipetest"), "endpoint should have been pipetest instead of %s\n", endpoint);
 612     todo_wine
 613     ok(options && !strcmp((char *)options, ""), "options should have been \"\" of \"%s\"\n", options);
 614     RpcStringFreeA(&uuid);
 615     RpcStringFreeA(&protseq);
 616     RpcStringFreeA(&network_addr);
 617     RpcStringFreeA(&endpoint);
 618     RpcStringFreeA(&options);
 619
 620     /* test all parameters with different type of string binding */
 621     status = RpcStringBindingParseA(valid_binding2, &uuid, &protseq, &network_addr, &endpoint, &options);
 622     ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
 623     ok(!strcmp((char *)uuid, "00000000-0000-0000-c000-000000000046"), "uuid should have been 00000000-0000-0000-C000-000000000046 instead of %s\n", uuid);
 624     ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
 625     ok(!strcmp((char *)network_addr, "."), "network_addr should have been . instead of %s\n", network_addr);
 626     ok(!strcmp((char *)endpoint, "pipetest"), "endpoint should have been pipetest instead of %s\n", endpoint);
 627     todo_wine
 628     ok(options && !strcmp((char *)options, ""), "options should have been \"\" of \"%s\"\n", options);
 629     RpcStringFreeA(&uuid);
 630     RpcStringFreeA(&protseq);
 631     RpcStringFreeA(&network_addr);
 632     RpcStringFreeA(&endpoint);
 633     RpcStringFreeA(&options);
 634
 635     /* test with as many parameters NULL as possible */
 636     status = RpcStringBindingParseA(valid_binding, NULL, &protseq, NULL, NULL, NULL);
 637     ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
 638     ok(!strcmp((char *)protseq, "ncacn_np"), "protseq should have been ncacn_np instead of %s\n", protseq);
 639     RpcStringFreeA(&protseq);
 640
 641     /* test with invalid uuid */
 642     status = RpcStringBindingParseA(invalid_uuid_binding, NULL, &protseq, NULL, NULL, NULL);
 643     ok(status == RPC_S_INVALID_STRING_UUID, "RpcStringBindingParseA should have returned RPC_S_INVALID_STRING_UUID instead of %d\n", status);
 644     ok(protseq == NULL, "protseq was %p instead of NULL\n", protseq);
 645
 646     /* test with invalid endpoint */
 647     status = RpcStringBindingParseA(invalid_ep_binding, NULL, &protseq, NULL, NULL, NULL);
 648     ok(status == RPC_S_OK, "RpcStringBindingParseA failed with error %d\n", status);
 649     RpcStringFreeA(&protseq);
 650
 651     /* test with invalid binding */
 652     status = RpcStringBindingParseA(invalid_binding, &uuid, &protseq, &network_addr, &endpoint, &options);
 653     todo_wine
 654     ok(status == RPC_S_INVALID_STRING_BINDING, "RpcStringBindingParseA should have returned RPC_S_INVALID_STRING_BINDING instead of %d\n", status);
 655     todo_wine
 656     ok(uuid == NULL, "uuid was %p instead of NULL\n", uuid);
 657     if (uuid)
 658         RpcStringFreeA(&uuid);
 659     ok(protseq == NULL, "protseq was %p instead of NULL\n", protseq);
 660     todo_wine
 661     ok(network_addr == NULL, "network_addr was %p instead of NULL\n", network_addr);
 662     if (network_addr)
 663         RpcStringFreeA(&network_addr);
 664     ok(endpoint == NULL, "endpoint was %p instead of NULL\n", endpoint);
 665     ok(options == NULL, "options was %p instead of NULL\n", options);
 666 }
 667
 668 static void test_I_RpcExceptionFilter(void)
 669 {
 670     ULONG exception;
 671     int retval;
 672     int (WINAPI *pI_RpcExceptionFilter)(ULONG) = (void *)GetProcAddress(GetModuleHandle("rpcrt4.dll"), "I_RpcExceptionFilter");
 673
 674     if (!pI_RpcExceptionFilter)
 675     {
 676         skip("I_RpcExceptionFilter not exported\n");
 677         return;
 678     }
 679
 680     for (exception = 0; exception < STATUS_REG_NAT_CONSUMPTION; exception++)
 681     {
 682         /* skip over uninteresting bits of the number space */
 683         if (exception == 2000) exception = 0x40000000;
 684         if (exception == 0x40000005) exception = 0x80000000;
 685         if (exception == 0x80000005) exception = 0xc0000000;
 686
 687         retval = pI_RpcExceptionFilter(exception);
 688         switch (exception)
 689         {
 690         case STATUS_DATATYPE_MISALIGNMENT:
 691         case STATUS_BREAKPOINT:
 692         case STATUS_ACCESS_VIOLATION:
 693         case STATUS_ILLEGAL_INSTRUCTION:
 694         case STATUS_PRIVILEGED_INSTRUCTION:
 695         case 0xc00000aa /* STATUS_INSTRUCTION_MISALIGNMENT */:
 696         case STATUS_STACK_OVERFLOW:
 697         case 0xc0000194 /* STATUS_POSSIBLE_DEADLOCK */:
 698             ok(retval == EXCEPTION_CONTINUE_SEARCH, "I_RpcExceptionFilter(0x%x) should have returned %d instead of %d\n",
 699                exception, EXCEPTION_CONTINUE_SEARCH, retval);
 700             break;
 701         case STATUS_GUARD_PAGE_VIOLATION:
 702         case STATUS_IN_PAGE_ERROR:
 703         case STATUS_HANDLE_NOT_CLOSABLE:
 704             trace("I_RpcExceptionFilter(0x%x) returned %d\n", exception, retval);
 705             break;
 706         default:
 707             ok(retval == EXCEPTION_EXECUTE_HANDLER, "I_RpcExceptionFilter(0x%x) should have returned %d instead of %d\n",
 708                exception, EXCEPTION_EXECUTE_HANDLER, retval);
 709         }
 710     }
 711 }
 712
 713 static void test_RpcStringBindingFromBinding(void)
 714 {
 715     static unsigned char ncacn_np[] = "ncacn_np";
 716     static unsigned char address[] = ".";
 717     static unsigned char endpoint[] = "\\pipe\\wine_rpc_test";
 718     RPC_STATUS status;
 719     handle_t handle;
 720     RPC_CSTR binding;
 721
 722     status = RpcStringBindingCompose(NULL, ncacn_np, address,
 723                                      endpoint, NULL, &binding);
 724     ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
 725
 726     status = RpcBindingFromStringBinding(binding, &handle);
 727     ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
 728     RpcStringFree(&binding);
 729
 730     status = RpcBindingToStringBinding(handle, &binding);
 731     ok(status == RPC_S_OK, "RpcStringBindingFromBinding failed with error %u\n", status);
 732
 733     ok(!strcmp((const char *)binding, "ncacn_np:.[\\\\pipe\\\\wine_rpc_test]"),
 734        "binding string didn't match what was expected: \"%s\"\n", binding);
 735     RpcStringFree(&binding);
 736
 737     status = RpcBindingFree(&handle);
 738     ok(status == RPC_S_OK, "RpcBindingFree failed with error %u\n", status);
 739 }
 740
 741 static char *printGuid(char *buf, int size, const UUID *guid)
 742 {
 743     snprintf(buf, size, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 744        guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1],
 745        guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5],
 746        guid->Data4[6], guid->Data4[7]);
 747     return buf;
 748 }
 749
 750 static void test_UuidCreate(void)
 751 {
 752     UUID guid;
 753     BYTE version;
 754
 755     UuidCreate(&guid);
 756     version = (guid.Data3 & 0xf000) >> 12;
 757     ok(version == 4 || broken(version == 1), "unexpected version %d\n",
 758        version);
 759     if (version == 4)
 760     {
 761         static UUID v4and = { 0, 0, 0x4000, { 0x80,0,0,0,0,0,0,0 } };
 762         static UUID v4or = { 0xffffffff, 0xffff, 0x4fff,
 763            { 0xbf,0xff,0xff,0xff,0xff,0xff,0xff,0xff } };
 764         UUID and, or;
 765         RPC_STATUS rslt;
 766         int i;
 767         char buf[39];
 768
 769         and = guid;
 770         or = guid;
 771         /* Generate a bunch of UUIDs and mask them.  By the end, we expect
 772          * every randomly generated bit to have been zero at least once,
 773          * resulting in no bits set in the and mask except those which are not
 774          * randomly generated:  the version number and the topmost bits of the
 775          * Data4 field (treated as big-endian.)  Similarly, we expect only
 776          * the bits which are not randomly set to be cleared in the or mask.
 777          */
 778         for (i = 0; i < 1000; i++)
 779         {
 780             LPBYTE src, dst;
 781
 782             UuidCreate(&guid);
 783             for (src = (LPBYTE)&guid, dst = (LPBYTE)&and;
 784              src - (LPBYTE)&guid < sizeof(guid); src++, dst++)
 785                 *dst &= *src;
 786             for (src = (LPBYTE)&guid, dst = (LPBYTE)&or;
 787              src - (LPBYTE)&guid < sizeof(guid); src++, dst++)
 788                 *dst |= *src;
 789         }
 790         ok(UuidEqual(&and, &v4and, &rslt),
 791            "unexpected bits set in V4 UUID: %s\n", printGuid(buf, sizeof(buf), &and));
 792         ok(UuidEqual(&or, &v4or, &rslt),
 793            "unexpected bits set in V4 UUID: %s\n", printGuid(buf, sizeof(buf), &or));
 794     }
 795     else
 796     {
 797         /* Older versions of Windows generate V1 UUIDs.  For these, there are
 798          * many stable bits, including at least the MAC address if one is
 799          * present.  Just check that Data4[0]'s most significant bits are
 800          * set as expected.
 801          */
 802         ok((guid.Data4[0] & 0xc0) == 0x80,
 803            "unexpected value in Data4[0]: %02x\n", guid.Data4[0] & 0xc0);
 804     }
 805 }
 806
 807 static void test_UuidCreateSequential(void)
 808 {
 809     UUID guid1;
 810     BYTE version;
 811     RPC_STATUS (WINAPI *pUuidCreateSequential)(UUID *) = (void *)GetProcAddress(GetModuleHandle("rpcrt4.dll"), "UuidCreateSequential");
 812     RPC_STATUS ret;
 813
 814     if (!pUuidCreateSequential)
 815     {
 816         skip("UuidCreateSequential not exported\n");
 817         return;
 818     }
 819     ret = pUuidCreateSequential(&guid1);
 820     ok(!ret || ret == RPC_S_UUID_LOCAL_ONLY,
 821        "expected RPC_S_OK or RPC_S_UUID_LOCAL_ONLY, got %08x\n", ret);
 822     version = (guid1.Data3 & 0xf000) >> 12;
 823     ok(version == 1, "unexpected version %d\n", version);
 824     if (version == 1)
 825     {
 826         UUID guid2;
 827
 828         if (!ret)
 829         {
 830             /* If the call succeeded, there's a valid (non-multicast) MAC
 831              * address in the uuid:
 832              */
 833             ok(!(guid1.Data4[2] & 0x01),
 834                "GUID does not appear to contain a MAC address\n");
 835         }
 836         else
 837         {
 838             /* Otherwise, there's a randomly generated multicast MAC address
 839              * address in the uuid:
 840              */
 841             ok((guid1.Data4[2] & 0x01),
 842                "GUID does not appear to contain a multicast MAC address\n");
 843         }
 844         /* Generate another GUID, and make sure its MAC address matches the
 845          * first.
 846          */
 847         ret = pUuidCreateSequential(&guid2);
 848         ok(!ret || ret == RPC_S_UUID_LOCAL_ONLY,
 849            "expected RPC_S_OK or RPC_S_UUID_LOCAL_ONLY, got %08x\n", ret);
 850         version = (guid2.Data3 & 0xf000) >> 12;
 851         ok(version == 1, "unexpected version %d\n", version);
 852         ok(!memcmp(guid1.Data4, guid2.Data4, sizeof(guid2.Data4)),
 853            "unexpected value in MAC address\n");
 854     }
 855 }
 856
 857 static void test_RpcBindingFree(void)
 858 {
 859     RPC_BINDING_HANDLE binding = NULL;
 860     RPC_STATUS status;
 861
 862     status = RpcBindingFree(&binding);
 863     ok(status == RPC_S_INVALID_BINDING,
 864        "RpcBindingFree should have retured RPC_S_INVALID_BINDING instead of %d\n",
 865        status);
 866 }
 867
 868 START_TEST( rpc )
 869 {
 870     UuidConversionAndComparison();
 871     TestDceErrorInqText();
 872     test_rpc_ncacn_ip_tcp();
 873     test_towers();
 874     test_I_RpcMapWin32Status();
 875     test_RpcStringBindingParseA();
 876     test_I_RpcExceptionFilter();
 877     test_RpcStringBindingFromBinding();
 878     test_UuidCreate();
 879     test_UuidCreateSequential();
 880     test_RpcBindingFree();
 881 }