ReactOS  0.4.12-dev-418-g3df31a8
rpc.c
Go to the documentation of this file.
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  {
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] = {
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 
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 */
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 
187 {
188  0
189 };
190 
192 {
193  0,
194  IFoo_table
195 };
196 
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}},
203  0,
204  0,
205  0,
206  0,
207  0,
208 };
209 
211 
212 static void test_rpc_ncacn_ip_tcp(void)
213 {
215  unsigned char *binding, *principal;
216  handle_t IFoo_IfHandle;
217  ULONG level, authnsvc, authzsvc;
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 
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 
233  "wrong RpcMgmtStopServerListening error (%u)\n", status);
234 
237  "wrong RpcMgmtWaitServerListen error status (%u)\n", status);
238 
239  status = RpcServerListen(1, 20, FALSE);
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 
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);
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 
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 
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 
291  ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
292  status);
293 
295  ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
296  status);
297 
299  ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
300 
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 } };
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);
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)) &&
370  ((tower->tower_length == 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);
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 
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 
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 
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";
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");
599  RpcStringFreeA(&protseq);
600  RpcStringFreeA(&network_addr);
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");
616  RpcStringFreeA(&protseq);
617  RpcStringFreeA(&network_addr);
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)
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 {
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 
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  {
677  case STATUS_BREAKPOINT:
684  ok(retval == EXCEPTION_CONTINUE_SEARCH, "I_RpcExceptionFilter(0x%x) should have returned %d instead of %d\n",
686  break;
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",
695  }
696  }
697 }
698 
700 {
701  static unsigned char ncacn_np[] = "ncacn_np";
702  static unsigned char address[] = ".";
703  static unsigned char endpoint[] = "\\pipe\\wine_rpc_test";
706  RPC_CSTR binding;
707 
709  endpoint, NULL, &binding);
710  ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
711 
713  ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
714  RpcStringFreeA(&binding);
715 
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 
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);
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);
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;
852 
853  status = RpcBindingFree(&binding);
855  "RpcBindingFree should have returned RPC_S_INVALID_BINDING instead of %d\n",
856  status);
857 }
858 
860 {
861  RPC_STATUS ret;
862  RPC_CSTR principal, saved_principal;
863  char *username;
864  ULONG len = 0;
865 
866  GetUserNameExA( NameSamCompatible, NULL, &len );
868  GetUserNameExA( NameSamCompatible, username, &len );
869 
871  ok( ret == RPC_S_UNKNOWN_AUTHN_SERVICE, "got %u\n", ret );
872 
874  ok( ret == RPC_S_UNKNOWN_AUTHN_SERVICE, "got %u\n", ret );
875 
876  principal = (RPC_CSTR)0xdeadbeef;
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 
889  ok( ret == RPC_S_OK, "got %u\n", ret );
890 
891  principal = (RPC_CSTR)0xdeadbeef;
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 );
903 }
904 
906 {
908 
910  ok(status == RPC_S_UNKNOWN_AUTHN_SERVICE, "status = %x\n", status);
911 }
912 
913 static void test_RpcServerUseProtseq(void)
914 {
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);
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);
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);
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 
1012 {
1013  static unsigned char annotation[] = "Test annotation string.";
1015  RPC_BINDING_VECTOR *binding_vector;
1016  handle_t handle;
1017  unsigned char *binding;
1018 
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 */
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 
1033  NULL, NULL, &binding);
1034  ok(status == RPC_S_OK, "%s: RpcStringBindingCompose failed (%u)\n", protseq, status);
1035 
1037  ok(status == RPC_S_OK, "%s: RpcBindingFromStringBinding failed (%u)\n", protseq, status);
1038 
1039  RpcStringFreeA(&binding);
1040 
1042  ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
1043 
1045  ok(status == RPC_S_OK || broken(status == RPC_S_SERVER_UNAVAILABLE), /* win9x */
1046  "%s: RpcEpResolveBinding failed with error %u\n", protseq, status);
1047 
1049  ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
1050 
1052  ok(status == RPC_S_OK, "%s: RpcBindingFree failed with error %u\n", protseq, status);
1053 
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 
1065 {
1066  HANDLE token;
1068  {
1070  DWORD size;
1071  BOOL ret;
1072 
1074  CloseHandle( token );
1075  return (ret && type == TokenElevationTypeFull);
1076  }
1077  return FALSE;
1078 }
1079 
1081 {
1082  HRESULT hr, init;
1083  INetFwMgr *mgr = NULL;
1084  INetFwPolicy *policy = NULL;
1086  VARIANT_BOOL enabled = VARIANT_FALSE;
1087 
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 
1114 {
1117 };
1118 
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;
1129 
1131  {
1132  SysFreeString( image );
1133  return E_FAIL;
1134  }
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 
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 
1200  test_towers();
1205  test_UuidCreate();
1210 
1211  if (firewall_enabled)
1212  {
1214  if (hr != S_OK)
1215  {
1216  skip("can't authorize app in firewall %08x\n", hr);
1217  return;
1218  }
1219  }
1220 
1223  test_endpoint_mapper(ncacn_np, np_address);
1224  test_endpoint_mapper(ncalrpc, NULL);
1225 
1226  if (firewall_enabled) set_firewall(APP_REMOVE);
1227 }
#define RPC_NT_NO_PROTSEQS_REGISTERED
Definition: ntstatus.h:974
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc)
Definition: rpc_binding.c:1547
#define RPC_S_UNKNOWN_IF
Definition: winerror.h:1028
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define RPC_X_SS_IN_NULL_CONTEXT
Definition: winerror.h:1083
#define STATUS_WRONG_PASSWORD
Definition: ntstatus.h:328
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:607
#define RPC_X_SS_CHAR_TRANS_OPEN_FAIL
Definition: winerror.h:1081
#define RPC_S_ENTRY_ALREADY_EXISTS
Definition: winerror.h:1068
#define trace(...)
Definition: kmt_test.h:217
GLint level
Definition: gl.h:1546
#define RPC_C_AUTHN_WINNT
Definition: rpcdce.h:158
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:784
enum _TOKEN_ELEVATION_TYPE TOKEN_ELEVATION_TYPE
#define RPC_NT_DUPLICATE_ENDPOINT
Definition: ntstatus.h:997
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
#define RPC_NT_SS_CONTEXT_MISMATCH
Definition: ntstatus.h:1050
#define RPC_S_UNSUPPORTED_TRANS_SYN
Definition: winerror.h:1040
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_SECURITY_DESCR
Definition: ntstatus.h:343
#define CloseHandle
Definition: compat.h:398
#define RPC_S_PROCNUM_OUT_OF_RANGE
Definition: winerror.h:1053
#define RPC_NT_INVALID_TIMEOUT
Definition: ntstatus.h:969
static void UuidConversionAndComparison(void)
Definition: rpc.c:81
#define STATUS_ILLEGAL_INSTRUCTION
Definition: ntstatus.h:252
#define RPC_NT_BAD_STUB_DATA
Definition: ntstatus.h:1057
#define ERROR_ACCOUNT_DISABLED
Definition: winerror.h:813
RPC_STATUS WINAPI RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)
Definition: rpc_server.c:1599
#define RPC_S_INVALID_BOUND
Definition: winerror.h:1043
#define RPC_NT_BYTE_COUNT_TOO_SMALL
Definition: ntstatus.h:1056
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define RPC_S_NO_ENDPOINT_FOUND
Definition: winerror.h:1019
#define ERROR_SUCCESS
Definition: deptool.c:10
#define RPC_X_NULL_REF_POINTER
Definition: winerror.h:1087
#define RPC_NT_NO_CONTEXT_AVAILABLE
Definition: ntstatus.h:1022
#define RPC_X_PIPE_EMPTY
Definition: winerror.h:1160
#define RPC_NT_INTERFACE_NOT_FOUND
Definition: ntstatus.h:1016
#define RPC_NT_UNKNOWN_AUTHZ_SERVICE
Definition: ntstatus.h:1007
#define RPC_X_SS_CONTEXT_DAMAGED
Definition: winerror.h:1084
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:343
void WINAPI I_RpcFree(void *Object)
Definition: rpcrt4_main.c:725
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:177
#define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL
Definition: ntstatus.h:1047
#define RPC_NT_CANNOT_SUPPORT
Definition: ntstatus.h:1021
#define RPC_X_SS_CHAR_TRANS_SHORT_FILE
Definition: winerror.h:1082
#define RPC_S_NO_CONTEXT_AVAILABLE
Definition: winerror.h:1073
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define RPC_S_NOTHING_TO_EXPORT
Definition: winerror.h:1062
#define RPC_S_NAME_SERVICE_UNAVAILABLE
Definition: winerror.h:1070
#define RPC_NT_NO_PROTSEQS
Definition: ntstatus.h:979
#define RPC_S_INVALID_NET_ADDR
Definition: winerror.h:1018
#define RPC_NT_ALREADY_LISTENING
Definition: ntstatus.h:973
#define exception
Definition: math.h:26
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:458
DWORD WINAPI FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:483
static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface
Definition: rpc.c:197
void(__RPC_STUB * RPC_DISPATCH_FUNCTION)(PRPC_MESSAGE Message)
Definition: rpcdcep.h:82
#define EPT_NT_CANT_CREATE
Definition: ntstatus.h:1032
char CHAR
Definition: xmlstorage.h:175
#define RPC_S_NO_BINDINGS
Definition: winerror.h:1029
#define RPC_S_NO_PROTSEQS_REGISTERED
Definition: winerror.h:1025
#define STATUS_REG_NAT_CONSUMPTION
Definition: ntstatus.h:807
#define RPC_NT_INVALID_TAG
Definition: ntstatus.h:991
#define RPC_S_WRONG_KIND_OF_BINDING
Definition: winerror.h:1012
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
#define RPC_NT_NO_MORE_MEMBERS
Definition: ntstatus.h:1014
#define RPC_NT_UNKNOWN_AUTHN_LEVEL
Definition: ntstatus.h:1005
#define RPC_S_INVALID_ASYNC_CALL
Definition: winerror.h:1157
static UUID Uuid_Table[10]
Definition: rpc.c:53
#define RPC_X_BYTE_COUNT_TOO_SMALL
Definition: winerror.h:1089
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)
Definition: rpc_epmap.c:596
#define STATUS_GUARD_PAGE_VIOLATION
Definition: ntstatus.h:170
#define RPC_NT_INVALID_RPC_PROTSEQ
Definition: ntstatus.h:964
void WINAPI SysFreeString(BSTR str)
Definition: oleaut.c:275
#define RPC_NT_SERVER_TOO_BUSY
Definition: ntstatus.h:983
#define STATUS_INSUFF_SERVER_RESOURCES
Definition: ntstatus.h:635
static void test_RpcServerUseProtseq(void)
Definition: rpc.c:913
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define RPC_NT_NO_CALL_ACTIVE
Definition: ntstatus.h:985
const char * wine_dbgstr_guid(const GUID *guid)
#define RPC_S_SERVER_UNAVAILABLE
Definition: winerror.h:1033
#define RPC_NT_UNKNOWN_AUTHN_TYPE
Definition: ntstatus.h:998
GLuint buffer
Definition: glext.h:5915
BOOLEAN WINAPI GetUserNameExA(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
Definition: sspi.c:1044
#define RPC_NT_ENUM_VALUE_OUT_OF_RANGE
Definition: ntstatus.h:1055
#define RPC_X_PIPE_CLOSED
Definition: winerror.h:1158
#define RPC_S_NO_MORE_BINDINGS
Definition: winerror.h:1113
#define RPC_NT_GROUP_MEMBER_NOT_FOUND
Definition: ntstatus.h:1031
static HRESULT set_firewall(enum firewall_op op)
Definition: rpc.c:1119
RPC_STATUS WINAPI RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR *ObjUuid, RPC_CSTR *Protseq, RPC_CSTR *NetworkAddr, RPC_CSTR *Endpoint, RPC_CSTR *Options)
Definition: rpc_binding.c:565
int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:253
#define STATUS_ACCOUNT_LOCKED_OUT
Definition: ntstatus.h:682
OLECHAR * BSTR
Definition: compat.h:1927
#define RPC_C_AUTHN_DEFAULT
Definition: rpcdce.h:165
static void test_I_RpcExceptionFilter(void)
Definition: rpc.c:654
char * LPSTR
Definition: xmlstorage.h:182
#define E_FAIL
Definition: ddrawi.h:102
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:161
#define RPC_NT_INVALID_BOUND
Definition: ntstatus.h:992
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
short VARIANT_BOOL
Definition: compat.h:1924
RPC_STATUS WINAPI RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, UINT WaitForCallsToComplete)
Definition: rpc_server.c:1209
static int init
Definition: wintirpc.c:33
RPC_STATUS RPC_ENTRY RpcBindingReset(RPC_BINDING_HANDLE Binding)
Definition: rpc_binding.c:1021
static void test_UuidCreate(void)
Definition: rpc.c:727
#define RPC_NT_INVALID_NAME_SYNTAX
Definition: ntstatus.h:994
#define RPC_NT_INVALID_VERS_OPTION
Definition: ntstatus.h:1013
#define RPC_S_INVALID_ENDPOINT_FORMAT
Definition: winerror.h:1017
static BOOL Uuid_Comparison_Grid[11][11]
Definition: rpc.c:67
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
#define STATUS_INVALID_LOGON_HOURS
Definition: ntstatus.h:333
#define EPT_NT_CANT_PERFORM_OP
Definition: ntstatus.h:1009
#define ERROR_WRONG_PASSWORD
Definition: winerror.h:805
RPC_STATUS WINAPI RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, LPVOID Arg)
Definition: rpc_server.c:1441
#define ERROR_MAX_THRDS_REACHED
Definition: winerror.h:235
#define RPC_S_UNKNOWN_AUTHN_LEVEL
Definition: winerror.h:1056
RPC_STATUS WINAPI RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
Definition: rpc_server.c:1067
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
long RPC_STATUS
Definition: rpc.h:52
RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, RPC_CSTR *StringUuid)
Definition: rpcrt4_main.c:515
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ERROR_NOACCESS
Definition: winerror.h:578
const GUID * guid
unsigned char * LPBYTE
Definition: typedefs.h:52
#define RPC_S_INVALID_OBJECT
Definition: winerror.h:1142
#define RPC_S_ZERO_DIVIDE
Definition: winerror.h:1075
void * RPC_IF_HANDLE
Definition: rpcdce.h:49
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:615
static D3DRMMATRIX4D identity
Definition: frame.c:29
#define RPC_NT_INVALID_NAF_ID
Definition: ntstatus.h:1020
#define RPC_NT_ZERO_DIVIDE
Definition: ntstatus.h:1024
long LONG
Definition: pedump.c:60
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
firewall_op
Definition: dplayx.c:6736
RPC_STATUS WINAPI RpcServerListen(UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait)
Definition: rpc_server.c:1527
#define RPC_NT_INVALID_STRING_UUID
Definition: ntstatus.h:965
#define ERROR_NOT_ENOUGH_SERVER_MEMORY
Definition: winerror.h:666
#define RPC_NT_INVALID_ASYNC_CALL
Definition: ntstatus.h:1044
#define RPC_NT_INTERNAL_ERROR
Definition: ntstatus.h:1023
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define RPC_S_INVALID_TAG
Definition: winerror.h:1042
#define RPC_S_FP_UNDERFLOW
Definition: winerror.h:1078
#define E_INVALIDARG
Definition: ddrawi.h:101
#define RPC_NT_CANT_CREATE_ENDPOINT
Definition: ntstatus.h:980
const WCHAR * str
#define RPC_S_CALL_FAILED_DNE
Definition: winerror.h:1038
#define ERROR_PASSWORD_MUST_CHANGE
Definition: winerror.h:1149
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:64
#define RPC_NT_INCOMPLETE_NAME
Definition: ntstatus.h:1012
static void TestDceErrorInqText(void)
Definition: rpc.c:144
#define STATUS_BREAKPOINT
Definition: ntstatus.h:172
#define RPC_NT_CALL_CANCELLED
Definition: ntstatus.h:1035
#define RPC_S_NO_ENTRY_NAME
Definition: winerror.h:1044
#define RPC_S_INVALID_TIMEOUT
Definition: winerror.h:1020
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:242
#define RPC_S_CANNOT_SUPPORT
Definition: winerror.h:1072
#define RPC_NT_PROCNUM_OUT_OF_RANGE
Definition: ntstatus.h:1002
#define RPC_NT_UNSUPPORTED_TRANS_SYN
Definition: ntstatus.h:989
Definition: rpc.c:44
#define RPC_S_INVALID_VERS_OPTION
Definition: winerror.h:1064
#define RPC_NT_UNKNOWN_IF
Definition: ntstatus.h:977
static RPC_IF_HANDLE IFoo_v0_0_s_ifspec
Definition: rpc.c:210
#define FORMAT_MESSAGE_FROM_SYSTEM
Definition: winbase.h:404
int options
Definition: main.c:106
#define RPC_NT_INVALID_OBJECT
Definition: ntstatus.h:1033
static void test_endpoint_mapper(RPC_CSTR protseq, RPC_CSTR address)
Definition: rpc.c:1011
#define RPC_S_FP_OVERFLOW
Definition: winerror.h:1079
byte tower_octet_string[1]
Definition: rpc.c:47
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026
#define ok(value,...)
Definition: CComObject.cpp:34
#define RPC_NT_ENTRY_ALREADY_EXISTS
Definition: ntstatus.h:1017
static WCHAR username[]
Definition: url.c:32
#define RPC_S_PROTOCOL_ERROR
Definition: winerror.h:1039
static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable
Definition: rpc.c:191
#define RPC_S_INTERFACE_NOT_FOUND
Definition: winerror.h:1067
#define RPC_S_INCOMPLETE_NAME
Definition: winerror.h:1063
RPC_STATUS WINAPI TowerExplode(const twr_t *tower, RPC_SYNTAX_IDENTIFIER *object, RPC_SYNTAX_IDENTIFIER *syntax, char **protseq, char **endpoint, char **address)
#define STATUS_ACCOUNT_DISABLED
Definition: ntstatus.h:336
RPC_STATUS WINAPI RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:917
#define RPC_S_PROTSEQ_NOT_SUPPORTED
Definition: winerror.h:1014
#define RPC_S_CALL_IN_PROGRESS
Definition: winerror.h:1098
#define RPC_S_DUPLICATE_ENDPOINT
Definition: winerror.h:1048
#define RPC_C_AUTHN_LEVEL_PKT_PRIVACY
Definition: rpcdce.h:151
#define RPC_NT_ALREADY_REGISTERED
Definition: ntstatus.h:971
#define RPC_S_UNSUPPORTED_TYPE
Definition: winerror.h:1041
#define RPC_S_INVALID_NETWORK_OPTIONS
Definition: winerror.h:1035
unsigned int BOOL
Definition: ntddk_ex.h:94
GLsizeiptr size
Definition: glext.h:5919
RPC_STATUS WINAPI RpcServerInqBindings(RPC_BINDING_VECTOR **BindingVector)
Definition: rpc_server.c:868
#define GetProcessHeap()
Definition: compat.h:395
static void test_UuidCreateSequential(void)
Definition: rpc.c:783
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define RPC_NT_SS_CANNOT_GET_CALL_HANDLE
Definition: ntstatus.h:1053
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:837
#define RPC_S_NO_PROTSEQS
Definition: winerror.h:1030
#define RPC_S_GROUP_MEMBER_NOT_FOUND
Definition: winerror.h:1140
#define TOKEN_QUERY
Definition: setypes.h:874
#define RPC_NT_UNKNOWN_MGR_TYPE
Definition: ntstatus.h:976
#define EPT_S_INVALID_ENTRY
Definition: winerror.h:1059
#define STATUS_PASSWORD_EXPIRED
Definition: ntstatus.h:335
#define RPC_NT_INVALID_NET_ADDR
Definition: ntstatus.h:967
LONG HRESULT
Definition: typedefs.h:77
RPC_STATUS WINAPI RpcServerUseProtseqEpA(RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:917
#define RPC_S_NOT_RPC_ERROR
Definition: winerror.h:1130
struct twr_t twr_t
#define RPC_NT_SS_IN_NULL_CONTEXT
Definition: ntstatus.h:1049
HANDLE WINAPI GetCurrentProcess(VOID)
Definition: proc.c:1168
#define RPC_S_UNKNOWN_MGR_TYPE
Definition: winerror.h:1027
#define RPC_NT_PIPE_EMPTY
Definition: ntstatus.h:1066
RPC_BINDING_HANDLE BindingH[1]
Definition: rpcdce.h:58
RPC_STATUS WINAPI RpcBindingVectorFree(RPC_BINDING_VECTOR **BindingVector)
Definition: rpc_binding.c:799
#define MAX_PATH
Definition: compat.h:26
#define RPC_S_OBJECT_NOT_FOUND
Definition: winerror.h:1021
struct endpoint endpoint
Definition: nis.h:15
#define RPC_NT_STRING_TOO_LONG
Definition: ntstatus.h:1000
static void test_rpc_ncacn_ip_tcp(void)
Definition: rpc.c:212
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint address
Definition: glext.h:9393
#define RPC_S_NO_MORE_MEMBERS
Definition: winerror.h:1065
RPC_STATUS WINAPI RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv)
Definition: rpc_server.c:1123
struct _RPC_SERVER_INTERFACE RPC_SERVER_INTERFACE
#define RPC_NT_NO_ENDPOINT_FOUND
Definition: ntstatus.h:968
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define RPC_NT_FP_UNDERFLOW
Definition: ntstatus.h:1027
#define RPC_S_TYPE_ALREADY_REGISTERED
Definition: winerror.h:1023
RPC_STATUS WINAPI RpcEpRegisterA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector, UUID_VECTOR *UuidVector, RPC_CSTR Annotation)
Definition: rpc_epmap.c:296
#define RPC_NT_FP_OVERFLOW
Definition: ntstatus.h:1028
RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR *StringUuid)
Definition: rpcrt4_main.c:541
#define RPC_S_INVALID_STRING_UUID
Definition: winerror.h:1016
#define RPC_S_CALL_CANCELLED
Definition: winerror.h:1125
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
static BOOL is_process_elevated(void)
Definition: rpc.c:1064
#define RPC_NT_FP_DIV_ZERO
Definition: ntstatus.h:1026
#define RPC_NT_INVALID_STRING_BINDING
Definition: ntstatus.h:960
#define RPC_NT_ENTRY_NOT_FOUND
Definition: ntstatus.h:1018
int ret
static const unsigned char tower_data_tcp_ip1[]
Definition: rpc.c:313
#define RPC_X_ENUM_VALUE_OUT_OF_RANGE
Definition: winerror.h:1088
#define RPC_NT_NOT_ALL_OBJS_UNEXPORTED
Definition: ntstatus.h:1015
#define todo_wine
Definition: test.h:154
#define RPC_S_MAX_CALLS_TOO_SMALL
Definition: winerror.h:1050
#define RPC_NT_INVALID_BINDING
Definition: ntstatus.h:962
#define RPC_NT_MAX_CALLS_TOO_SMALL
Definition: ntstatus.h:999
#define RPC_S_UNSUPPORTED_NAME_SYNTAX
Definition: winerror.h:1046
#define RPC_S_UUID_NO_ADDRESS
Definition: winerror.h:1047
#define RPC_NT_INVALID_NETWORK_OPTIONS
Definition: ntstatus.h:984
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
#define ERROR_INVALID_SECURITY_DESCR
Definition: winerror.h:820
GLenum GLsizei len
Definition: glext.h:6722
#define RPC_NT_OBJECT_NOT_FOUND
Definition: ntstatus.h:970
unsigned char BYTE
Definition: mem.h:68
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:819
#define RPC_S_ADDRESS_ERROR
Definition: winerror.h:1076
#define STATUS_HANDLE_NOT_CLOSABLE
Definition: ntstatus.h:683
#define STATUS_PRIVILEGED_INSTRUCTION
Definition: ntstatus.h:372
#define RPC_NT_NO_MORE_ENTRIES
Definition: ntstatus.h:1046
GLenum src
Definition: glext.h:6340
static void test_RpcServerRegisterAuthInfo(void)
Definition: rpc.c:905
static RPC_DISPATCH_FUNCTION IFoo_table[]
Definition: rpc.c:186
#define RPC_S_NO_CALL_ACTIVE
Definition: winerror.h:1036
#define RPC_NT_UNSUPPORTED_NAME_SYNTAX
Definition: ntstatus.h:995
#define RPC_S_INTERNAL_ERROR
Definition: winerror.h:1074
static void test_towers(void)
Definition: rpc.c:341
#define RPC_NT_TYPE_ALREADY_REGISTERED
Definition: ntstatus.h:972
static const unsigned char tower_data_tcp_ip2[]
Definition: rpc.c:327
#define WINAPI
Definition: msvc.h:20
#define ERROR_INVALID_LOGON_HOURS
Definition: winerror.h:810
#define STATUS_POSSIBLE_DEADLOCK
Definition: ntstatus.h:623
RPC_STATUS WINAPI RpcEpUnregister(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector, UUID_VECTOR *UuidVector)
Definition: rpc_epmap.c:344
#define broken(x)
Definition: _sntprintf.h:21
unsigned32 tower_length
Definition: rpc.c:46
#define RPC_X_SS_CANNOT_GET_CALL_HANDLE
Definition: winerror.h:1086
#define RPC_S_ALREADY_LISTENING
Definition: winerror.h:1024
#define RPC_S_INVALID_RPC_PROTSEQ
Definition: winerror.h:1015
#define RPC_S_SERVER_TOO_BUSY
Definition: winerror.h:1034
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3237
#define RPC_S_INVALID_NAME_SYNTAX
Definition: winerror.h:1045
static void test_RpcServerInqDefaultPrincName(void)
Definition: rpc.c:859
#define RPC_NT_SS_CONTEXT_DAMAGED
Definition: ntstatus.h:1051
#define RPC_NT_PROTOCOL_ERROR
Definition: ntstatus.h:988
#define RPC_S_BINDING_HAS_NO_AUTH
Definition: winerror.h:1054
#define FORMAT_MESSAGE_IGNORE_INSERTS
Definition: winbase.h:401
#define RPC_NT_SS_HANDLES_MISMATCH
Definition: ntstatus.h:1052
#define RPC_NT_CALL_IN_PROGRESS
Definition: ntstatus.h:1029
static void test_RpcStringBindingFromBinding(void)
Definition: rpc.c:699
#define ERROR_PASSWORD_EXPIRED
Definition: winerror.h:812
#define S_OK
Definition: intsafe.h:59
Definition: nis.h:10
#define RPC_NT_UNKNOWN_AUTHN_SERVICE
Definition: ntstatus.h:1004
#define STATUS_INSTRUCTION_MISALIGNMENT
Definition: ntstatus.h:392
unsigned int unsigned32
Definition: rpc.c:43
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
Definition: rpcrt4_main.c:306
static void test_RpcBindingFree(void)
Definition: rpc.c:848
#define RPC_NT_CALL_FAILED_DNE
Definition: ntstatus.h:987
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
INT x
Definition: msvc.h:62
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:1994
#define STATUS_PASSWORD_MUST_CHANGE
Definition: ntstatus.h:666
static BOOL is_firewall_enabled(void)
Definition: rpc.c:1080
#define RPC_NT_INVALID_AUTH_IDENTITY
Definition: ntstatus.h:1006
static void test_RpcStringBindingParseA(void)
Definition: rpc.c:573
#define skip(...)
Definition: CString.cpp:57
#define RPC_X_SS_HANDLES_MISMATCH
Definition: winerror.h:1085
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
#define RPC_NT_PIPE_DISCIPLINE_ERROR
Definition: ntstatus.h:1065
GLenum GLenum dst
Definition: glext.h:6340
#define RPC_NT_NO_ENTRY_NAME
Definition: ntstatus.h:993
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:1938
#define RPC_NT_INVALID_ENDPOINT_FORMAT
Definition: ntstatus.h:966
#define RPC_NT_PIPE_CLOSED
Definition: ntstatus.h:1064
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define EPT_S_NOT_REGISTERED
Definition: winerror.h:1061
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:296
#define STATUS_STACK_OVERFLOW
Definition: ntstatus.h:475
#define RPC_S_INVALID_NAF_ID
Definition: winerror.h:1071
RPC_STATUS WINAPI RpcEpResolveBinding(RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec)
Definition: rpc_epmap.c:431
#define RPC_NT_INVALID_ASYNC_HANDLE
Definition: ntstatus.h:1043
#define RPC_S_ENTRY_NOT_FOUND
Definition: winerror.h:1069
#define RPC_X_NO_MORE_ENTRIES
Definition: winerror.h:1080
#define RPC_C_AUTHZ_NAME
Definition: rpcdce.h:168
Definition: name.c:36
#define EPT_S_CANT_CREATE
Definition: winerror.h:1141
#define STATUS_DATATYPE_MISALIGNMENT
Definition: ntstatus.h:171
#define RPC_NT_NAME_SERVICE_UNAVAILABLE
Definition: ntstatus.h:1019
#define RPC_S_UNKNOWN_AUTHZ_SERVICE
Definition: winerror.h:1058
#define EPT_NT_NOT_REGISTERED
Definition: ntstatus.h:1010
#define RPC_X_BAD_STUB_DATA
Definition: winerror.h:1090
#define RPC_NT_NOTHING_TO_EXPORT
Definition: ntstatus.h:1011
Definition: msctf.idl:510
unsigned int ULONG
Definition: retypes.h:1
BOOL WINAPI GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength)
Definition: security.c:413
Definition: rpc.c:1115
#define annotation(x)
Definition: dispex.idl:19
#define RPC_NT_BINDING_HAS_NO_AUTH
Definition: ntstatus.h:1003
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
RPC_STATUS WINAPI RpcMgmtWaitServerListen(void)
Definition: rpc_server.c:1546
START_TEST(rpc)
Definition: rpc.c:1185
#define GetProcAddress(x, y)
Definition: compat.h:410
#define profile
Definition: kernel32.h:12
UINT op
Definition: effect.c:223
#define EPT_S_CANT_PERFORM_OP
Definition: winerror.h:1060
#define STATUS_IN_PAGE_ERROR
Definition: ntstatus.h:229
#define RPC_S_INVALID_AUTH_IDENTITY
Definition: winerror.h:1057
static void test_I_RpcMapWin32Status(void)
Definition: rpc.c:429
RPC_STATUS WINAPI UuidFromStringA(RPC_CSTR s, UUID *uuid)
Definition: rpcrt4_main.c:575
#define RPC_NT_UNSUPPORTED_TYPE
Definition: ntstatus.h:990
WCHAR * LPWSTR
Definition: xmlstorage.h:184
RPC_STATUS RPC_ENTRY DceErrorInqTextA(RPC_STATUS e, RPC_CSTR buffer)
Definition: rpcrt4_main.c:698
#define RPC_S_CALL_FAILED
Definition: winerror.h:1037
#define RPC_NT_NULL_REF_POINTER
Definition: ntstatus.h:1054
#define RPC_NT_OUT_OF_RESOURCES
Definition: ntstatus.h:981
#define ERROR_ACCOUNT_LOCKED_OUT
Definition: winerror.h:1151
#define RPC_NT_CALL_FAILED
Definition: ntstatus.h:986
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, ULONG AuthnLevel, ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr)
Definition: rpc_binding.c:1930
#define RPC_S_INVALID_STRING_BINDING
Definition: winerror.h:1011
#define RPC_S_NOT_ALL_OBJS_UNEXPORTED
Definition: winerror.h:1066
static SERVICE_STATUS status
Definition: service.c:31
RPC_STATUS WINAPI RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, LPVOID Arg)
Definition: rpc_server.c:1421
#define EPT_NT_INVALID_ENTRY
Definition: ntstatus.h:1008
#define win_skip
Definition: test.h:141
#define RPC_C_AUTHN_LEVEL_NONE
Definition: rpcdce.h:146
#define RPC_NT_WRONG_KIND_OF_BINDING
Definition: ntstatus.h:961
#define HeapFree(x, y, z)
Definition: compat.h:394
#define RPC_S_PROTSEQ_NOT_FOUND
Definition: winerror.h:1052
RPC_STATUS WINAPI RpcNetworkIsProtseqValidA(RPC_CSTR protseq)
#define RPC_S_UUID_LOCAL_ONLY
Definition: winerror.h:1131
#define RPC_S_INVALID_ASYNC_HANDLE
Definition: winerror.h:1156
RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameA(ULONG AuthnSvc, RPC_CSTR *PrincName)
Definition: rpc_server.c:1488
void * object
Definition: jmemsys.h:48
static const WCHAR testW[]
Definition: jsregexp.c:44
#define RPC_S_UNKNOWN_AUTHN_TYPE
Definition: winerror.h:1049
#define RPC_S_ALREADY_REGISTERED
Definition: winerror.h:1022
#define RPC_NT_NO_MORE_BINDINGS
Definition: ntstatus.h:1030
#define RPC_NT_SERVER_UNAVAILABLE
Definition: ntstatus.h:982
#define RPC_NT_NO_BINDINGS
Definition: ntstatus.h:978
#define RPC_S_OK
Definition: rpcnterr.h:22
#define SUCCEEDED(hr)
Definition: intsafe.h:57
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define RPC_S_CANT_CREATE_ENDPOINT
Definition: winerror.h:1031
#define RPC_NT_SS_CHAR_TRANS_SHORT_FILE
Definition: ntstatus.h:1048
#define RPC_NT_UUID_NO_ADDRESS
Definition: ntstatus.h:996
#define printf
Definition: config.h:203
#define RPC_S_STRING_TOO_LONG
Definition: winerror.h:1051
#define RPC_NT_NOT_LISTENING
Definition: ntstatus.h:975
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:29
#define RPC_NT_PROTSEQ_NOT_FOUND
Definition: ntstatus.h:1001
#define RPC_NT_PROTSEQ_NOT_SUPPORTED
Definition: ntstatus.h:963
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define RPC_X_PIPE_DISCIPLINE_ERROR
Definition: winerror.h:1159
#define RPC_NT_ADDRESS_ERROR
Definition: ntstatus.h:1025
#define RPC_S_FP_DIV_ZERO
Definition: winerror.h:1077
LONG WINAPI I_RpcMapWin32Status(RPC_STATUS status)
Definition: rpcrt4_main.c:741
Definition: ps.c:97
GLuint const GLchar * name
Definition: glext.h:6031