ReactOS  0.4.13-dev-39-g8b6696f
server.c
Go to the documentation of this file.
1 /*
2  * Tests for WIDL and RPC server/clients.
3  *
4  * Copyright (C) Google 2007 (Dan Hipschman)
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 #define COBJMACROS
22 #include <windows.h>
23 #include <ole2.h>
24 #include <oleauto.h>
25 #include <secext.h>
26 #include <rpcdce.h>
27 #include <netfw.h>
28 #include "wine/test.h"
29 #include "server_s.h"
30 #include "server_defines.h"
31 
32 #include <stddef.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 
36 #define PORT "4114"
37 #define PIPE "\\pipe\\wine_rpcrt4_test"
38 
39 #define INT_CODE 4198
40 
41 static const char *progname;
43 
45 
46 static void (WINAPI *pNDRSContextMarshall2)(RPC_BINDING_HANDLE, NDR_SCONTEXT, void*, NDR_RUNDOWN, void*, ULONG);
47 static NDR_SCONTEXT (WINAPI *pNDRSContextUnmarshall2)(RPC_BINDING_HANDLE, void*, ULONG, void*, ULONG);
48 static RPC_STATUS (WINAPI *pRpcServerRegisterIfEx)(RPC_IF_HANDLE,UUID*, RPC_MGR_EPV*, unsigned int,
49  unsigned int,RPC_IF_CALLBACK_FN*);
50 static RPC_STATUS (WINAPI *pRpcBindingSetAuthInfoExA)(RPC_BINDING_HANDLE, RPC_CSTR, ULONG, ULONG,
52 static RPC_STATUS (WINAPI *pRpcServerRegisterAuthInfoA)(RPC_CSTR, ULONG, RPC_AUTH_KEY_RETRIEVAL_FN, LPVOID);
53 
54 static char *domain_and_user;
55 
56 /* type check statements generated in header file */
58 
59 static const WCHAR helloW[] = { 'H','e','l','l','o',0 };
60 static const WCHAR worldW[] = { 'W','o','r','l','d','!',0 };
61 
62 static void InitFunctionPointers(void)
63 {
64  HMODULE hrpcrt4 = GetModuleHandleA("rpcrt4.dll");
65 
66  pNDRSContextMarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextMarshall2");
67  pNDRSContextUnmarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextUnmarshall2");
68  pRpcServerRegisterIfEx = (void *)GetProcAddress(hrpcrt4, "RpcServerRegisterIfEx");
69  pRpcBindingSetAuthInfoExA = (void *)GetProcAddress(hrpcrt4, "RpcBindingSetAuthInfoExA");
70  pRpcServerRegisterAuthInfoA = (void *)GetProcAddress(hrpcrt4, "RpcServerRegisterAuthInfoA");
71 
72  if (!pNDRSContextMarshall2) old_windows_version = TRUE;
73 }
74 
77 {
78  return HeapAlloc(GetProcessHeap(), 0, n);
79 }
80 
81 void __RPC_USER
83 {
84  HeapFree(GetProcessHeap(), 0, p);
85 }
86 
87 static char *
88 xstrdup(const char *s)
89 {
90  char *d = HeapAlloc(GetProcessHeap(), 0, strlen(s) + 1);
91  strcpy(d, s);
92  return d;
93 }
94 
96 {
97  return INT_CODE;
98 }
99 
101 {
102  return x * x;
103 }
104 
105 int __cdecl s_sum(int x, int y)
106 {
107  return x + y;
108 }
109 
110 signed char __cdecl s_sum_char(signed char x, signed char y)
111 {
112  return x + y;
113 }
114 
115 short __cdecl s_sum_short(short x, short y)
116 {
117  return x + y;
118 }
119 
120 int __cdecl s_sum_float(float x, float y)
121 {
122  return x + y;
123 }
124 
125 int __cdecl s_sum_double_int(int x, double y)
126 {
127  return x + y;
128 }
129 
131 {
132  return x + y;
133 }
134 
136 {
137  return x + y;
138 }
139 
140 int __cdecl s_sum_char_hyper(signed char x, hyper y)
141 {
142  return x + y;
143 }
144 
145 void __cdecl s_square_out(int x, int *y)
146 {
147  *y = s_square(x);
148 }
149 
151 {
152  *x = s_square(*x);
153 }
154 
155 int __cdecl s_str_length(const char *s)
156 {
157  return strlen(s);
158 }
159 
161 {
162  return strlen(s);
163 }
164 
165 int __cdecl s_cstr_length(const char *s, int n)
166 {
167  int len = 0;
168  while (0 < n-- && *s++)
169  ++len;
170  return len;
171 }
172 
174 {
175  return s_square(v->x) + s_square(v->y) + s_square(v->z);
176 }
177 
178 double __cdecl s_square_half(double x, double *y)
179 {
180  *y = x / 2.0;
181  return x * x;
182 }
183 
184 float __cdecl s_square_half_float(float x, float *y)
185 {
186  *y = x / 2.0f;
187  return x * x;
188 }
189 
191 {
192  *y = x / 2;
193  return x * x;
194 }
195 
197 {
198  return a[0] + a[1] + a[2] + a[3] + a[4];
199 }
200 
201 int __cdecl s_pints_sum(pints_t *pints)
202 {
203  return *pints->pi + **pints->ppi + ***pints->pppi;
204 }
205 
206 double __cdecl s_ptypes_sum(ptypes_t *pt)
207 {
208  return *pt->pc + *pt->ps + *pt->pl + *pt->pf + *pt->pd;
209 }
210 
211 int __cdecl s_dot_pvectors(pvectors_t *p)
212 {
213  return p->pu->x * (*p->pv)->x + p->pu->y * (*p->pv)->y + p->pu->z * (*p->pv)->z;
214 }
215 
216 int __cdecl s_sum_sp(sp_t *sp)
217 {
218  return sp->x + sp->s->x;
219 }
220 
221 double __cdecl s_square_sun(sun_t *su)
222 {
223  switch (su->s)
224  {
225  case SUN_I: return su->u.i * su->u.i;
226  case SUN_F1:
227  case SUN_F2: return su->u.f * su->u.f;
228  case SUN_PI: return (*su->u.pi) * (*su->u.pi);
229  default:
230  return 0.0;
231  }
232 }
233 
234 int __cdecl s_test_list_length(test_list_t *list)
235 {
236  return (list->t == TL_LIST
237  ? 1 + s_test_list_length(list->u.tail)
238  : 0);
239 }
240 
241 int __cdecl s_sum_fixed_int_3d(int m[2][3][4])
242 {
243  int i, j, k;
244  int sum = 0;
245 
246  for (i = 0; i < 2; ++i)
247  for (j = 0; j < 3; ++j)
248  for (k = 0; k < 4; ++k)
249  sum += m[i][j][k];
250 
251  return sum;
252 }
253 
254 int __cdecl s_sum_conf_array(int x[], int n)
255 {
256  int *p = x, *end = p + n;
257  int sum = 0;
258 
259  while (p < end)
260  sum += *p++;
261 
262  return sum;
263 }
264 
265 int __cdecl s_sum_conf_ptr_by_conf_ptr(int n1, int *n2_then_x1, int *x2)
266 {
267  int i;
268  int sum = 0;
269  if(n1 == 0)
270  return 0;
271 
272  for(i = 1; i < n1; ++i)
273  sum += n2_then_x1[i];
274 
275  for(i = 0; i < *n2_then_x1; ++i)
276  sum += x2[i];
277 
278  return sum;
279 }
280 
282 {
283  return s_sum_conf_array(x, n);
284 }
285 
287 {
288  return x ? s_sum_conf_array(x, n) : 0;
289 }
290 
291 int __cdecl s_sum_var_array(int x[20], int n)
292 {
293  ok(0 <= n, "RPC sum_var_array\n");
294  ok(n <= 20, "RPC sum_var_array\n");
295 
296  return s_sum_conf_array(x, n);
297 }
298 
299 int __cdecl s_sum_complex_array(int n, refpint_t pi[])
300 {
301  int total = 0;
302  for (; n > 0; n--)
303  total += *pi[n - 1];
304  return total;
305 }
306 
308 {
309  return vs[0].x * vs[1].x + vs[0].y * vs[1].y + vs[0].z * vs[1].z;
310 }
311 
312 void __cdecl s_get_number_array(int x[20], int *n)
313 {
314  int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
315  memcpy(x, c, sizeof(c));
316  *n = ARRAY_SIZE(c);
317 }
318 
319 int __cdecl s_sum_cs(cs_t *cs)
320 {
321  return s_sum_conf_array(cs->ca, cs->n);
322 }
323 
324 int __cdecl s_sum_cps(cps_t *cps)
325 {
326  int sum = 0;
327  int i;
328 
329  for (i = 0; i < *cps->pn; ++i)
330  sum += cps->ca1[i];
331 
332  for (i = 0; i < 2 * cps->n; ++i)
333  sum += cps->ca2[i];
334 
335  return sum;
336 }
337 
338 int __cdecl s_sum_cpsc(cpsc_t *cpsc)
339 {
340  int sum = 0;
341  int i;
342  for (i = 0; i < (cpsc->c ? cpsc->a : cpsc->b); ++i)
343  sum += cpsc->ca[i];
344  return sum;
345 }
346 
347 int __cdecl s_get_cpsc(int n, cpsc_t *cpsc)
348 {
349  int i, ret;
350 
351  cpsc->a = 2 * n;
352  cpsc->b = 2;
353  cpsc->c = 1;
354  cpsc->ca = MIDL_user_allocate( cpsc->a * sizeof(int) );
355  for (i = ret = 0; i < cpsc->a; i++) cpsc->ca[i] = i;
356  for (i = ret = 0; i < cpsc->a; i++) ret += cpsc->ca[i];
357  return ret;
358 }
359 
361 {
362  int n = atoi(p);
363  return n * n;
364 }
365 
366 int __cdecl s_sum_puints(puints_t *p)
367 {
368  int sum = 0;
369  int i;
370  for (i = 0; i < p->n; ++i)
371  sum += atoi(p->ps[i]);
372  return sum;
373 }
374 
375 int __cdecl s_sum_cpuints(cpuints_t *p)
376 {
377  int sum = 0;
378  int i;
379  for (i = 0; i < p->n; ++i)
380  sum += atoi(p->ps[i]);
381  return sum;
382 }
383 
385 {
386  return u.x * v.x + u.y * v.y + u.z * v.z;
387 }
388 
389 int __cdecl s_square_test_us(test_us_t *tus)
390 {
391  int n = atoi(tus->us.x);
392  return n * n;
393 }
394 
395 double __cdecl s_square_encu(encu_t *eu)
396 {
397  switch (eu->t)
398  {
399  case ENCU_I: return eu->tagged_union.i * eu->tagged_union.i;
400  case ENCU_F: return eu->tagged_union.f * eu->tagged_union.f;
401  default:
402  return 0.0;
403  }
404 }
405 
406 double __cdecl s_square_unencu(int t, unencu_t *eu)
407 {
408  switch (t)
409  {
410  case ENCU_I: return eu->i * eu->i;
411  case ENCU_F: return eu->f * eu->f;
412  default:
413  return 0.0;
414  }
415 }
416 
417 void __cdecl s_check_se2(se_t *s)
418 {
419  ok(s->f == E2, "check_se2\n");
420 }
421 
422 int __cdecl s_sum_parr(int *a[3])
423 {
424  return s_sum_pcarr(a, 3);
425 }
426 
427 int __cdecl s_sum_pcarr(int *a[], int n)
428 {
429  int i, s = 0;
430  for (i = 0; i < n; ++i)
431  s += *a[i];
432  return s;
433 }
434 
436 {
437  switch (e)
438  {
439  case E1: return 1;
440  case E2: return 2;
441  case E3: return 3;
442  case E4: return 4;
443  default:
444  return 0;
445  }
446 }
447 
448 double __cdecl s_square_encue(encue_t *eue)
449 {
450  switch (eue->t)
451  {
452  case E1: return eue->tagged_union.i1 * eue->tagged_union.i1;
453  case E2: return eue->tagged_union.f2 * eue->tagged_union.f2;
454  default:
455  return 0.0;
456  }
457 }
458 
460 {
461  int sum = 0;
462  int i;
463  for (i = 0; i < 2 * n; ++i)
464  sum += x[i];
465  return sum;
466 }
467 
468 int __cdecl s_sum_toplev_conf_cond(int *x, int a, int b, int c)
469 {
470  int sum = 0;
471  int n = c ? a : b;
472  int i;
473  for (i = 0; i < n; ++i)
474  sum += x[i];
475  return sum;
476 }
477 
478 double __cdecl s_sum_aligns(aligns_t *a)
479 {
480  return a->c + a->i + a->s + a->d;
481 }
482 
483 int __cdecl s_sum_padded(padded_t *p)
484 {
485  return p->i + p->c;
486 }
487 
488 int __cdecl s_sum_padded2(padded_t ps[2])
489 {
490  return s_sum_padded(&ps[0]) + s_sum_padded(&ps[1]);
491 }
492 
493 int __cdecl s_sum_padded_conf(padded_t *ps, int n)
494 {
495  int sum = 0;
496  int i;
497  for (i = 0; i < n; ++i)
498  sum += s_sum_padded(&ps[i]);
499  return sum;
500 }
501 
502 int __cdecl s_sum_bogus(bogus_t *b)
503 {
504  return *b->h.p1 + *b->p2 + *b->p3 + b->c;
505 }
506 
507 void __cdecl s_check_null(int *null)
508 {
509  ok(!null, "RPC check_null\n");
510 }
511 
512 int __cdecl s_str_struct_len(str_struct_t *s)
513 {
514  return lstrlenA(s->s);
515 }
516 
517 int __cdecl s_wstr_struct_len(wstr_struct_t *s)
518 {
519  return lstrlenW(s->s);
520 }
521 
522 int __cdecl s_sum_doub_carr(doub_carr_t *dc)
523 {
524  int i, j;
525  int sum = 0;
526  for (i = 0; i < dc->n; ++i)
527  for (j = 0; j < dc->a[i]->n; ++j)
528  sum += dc->a[i]->a[j];
529  return sum;
530 }
531 
532 void __cdecl s_make_pyramid_doub_carr(unsigned char n, doub_carr_t **dc)
533 {
534  doub_carr_t *t;
535  int i, j;
536  t = MIDL_user_allocate(FIELD_OFFSET(doub_carr_t, a[n]));
537  t->n = n;
538  for (i = 0; i < n; ++i)
539  {
540  int v = i + 1;
541  t->a[i] = MIDL_user_allocate(FIELD_OFFSET(doub_carr_1_t, a[v]));
542  t->a[i]->n = v;
543  for (j = 0; j < v; ++j)
544  t->a[i]->a[j] = j + 1;
545  }
546  *dc = t;
547 }
548 
550 {
551  short n = b[-1];
552  short *s = b;
553  unsigned hash = 0;
554  short i;
555  for (i = 0; i < n; ++i)
556  hash = 5 * hash + (unsigned) s[i];
557  return hash;
558 }
559 
561 {
562  bstr_t bstr;
563  short str[] = {5, 'W', 'i', 'n', 'e', 0};
564  bstr = HeapAlloc(GetProcessHeap(), 0, sizeof(str));
565  memcpy(bstr, str, sizeof(str));
566  *b = bstr + 1;
567 }
568 
569 void __cdecl s_get_name(name_t *name)
570 {
571  const char bossman[] = "Jeremy White";
572  memcpy(name->name, bossman, min(name->size, sizeof(bossman)));
573  /* ensure nul-termination */
574  if (name->size < sizeof(bossman))
575  name->name[name->size - 1] = 0;
576 }
577 
578 void __cdecl s_get_names(int *n, str_array_t *names)
579 {
580  str_array_t list;
581 
582  list = MIDL_user_allocate(2 * sizeof(list[0]));
583  list[0] = MIDL_user_allocate(6);
584  strcpy(list[0], "Hello");
585  list[1] = MIDL_user_allocate(7);
586  strcpy(list[1], "World!");
587 
588  *names = list;
589  *n = 2;
590 }
591 
592 void __cdecl s_get_namesw(int *n, wstr_array_t *names)
593 {
594  wstr_array_t list;
595 
596  list = MIDL_user_allocate(2 * sizeof(list[0]));
597  list[0] = MIDL_user_allocate(sizeof(helloW));
598  lstrcpyW(list[0], helloW);
599  list[1] = MIDL_user_allocate(sizeof(worldW));
600  lstrcpyW(list[1], worldW);
601 
602  *names = list;
603  *n = 2;
604 }
605 
606 int __cdecl s_sum_pcarr2(int n, int **pa)
607 {
608  return s_sum_conf_array(*pa, n);
609 }
610 
612 {
613  int i;
614  int sum = 0;
615  for (i = 0; i < n; ++i)
616  sum += abs(vs[i].x) + abs(vs[i].y) + abs(vs[i].z);
617  return sum;
618 }
619 
620 s123_t * __cdecl s_get_s123(void)
621 {
622  s123_t *s = MIDL_user_allocate(sizeof *s);
623  s->f1 = 1;
624  s->f2 = 2;
625  s->f3 = 3;
626  return s;
627 }
628 
630 {
631  return (char *)__FILE__;
632 }
633 
634 int __cdecl s_echo_ranged_int(int i, int j, int k)
635 {
636  return min( 100, i + j + k );
637 }
638 
640 {
641  return i;
642 }
643 
644 void __cdecl s_get_ranged_enum(renum_t *re)
645 {
646  *re = RE3;
647 }
648 
650 {
651  NDR_SCONTEXT h;
652  RPC_BINDING_HANDLE binding;
654  unsigned char buf[20];
655  static RPC_SERVER_INTERFACE server_if =
656  {
657  sizeof(RPC_SERVER_INTERFACE),
658  {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
659  {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
660  NULL,
661  0,
662  0,
663  0,
664  0,
665  0,
666  };
667 
668  binding = I_RpcGetCurrentCallHandle();
669  ok(binding != NULL, "I_RpcGetCurrentCallHandle returned NULL\n");
670 
671  if (!pNDRSContextMarshall2 || !pNDRSContextUnmarshall2)
672  {
673  win_skip("NDRSContextMarshall2 or NDRSContextUnmarshall2 not exported from rpcrt4.dll\n");
674  return;
675  }
676 
677  h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
678  ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
679 
680  /* marshal a context handle with NULL userContext */
681  memset(buf, 0xcc, sizeof(buf));
682  pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
683  ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
684  ok(UuidIsNil((UUID *)&buf[4], &status), "uuid should have been nil\n");
685 
686  h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
687  ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
688 
689  /* marshal a context handle with non-NULL userContext */
690  memset(buf, 0xcc, sizeof(buf));
691  h->userContext = (void *)0xdeadbeef;
692  pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
693  ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
694  ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
695 
696  /* raises ERROR_INVALID_HANDLE exception on Vista upwards */
697  if (0)
698  {
699  h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
700  ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
701  ok(h->userContext == (void *)0xdeadbeef, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
702 
703  /* marshal a context handle with an interface specified */
704  h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
705  ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
706 
707  memset(buf, 0xcc, sizeof(buf));
708  h->userContext = (void *)0xcafebabe;
709  pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
710  ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
711  ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
712 
713  h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
714  ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
715  ok(h->userContext == (void *)0xcafebabe, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
716  }
717 
718  /* test same interface data, but different pointer */
719  /* raises ERROR_INVALID_HANDLE exception */
720  if (0)
721  {
722  RPC_SERVER_INTERFACE server_if_clone = server_if;
723 
724  pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if_clone.InterfaceId, 0);
725  }
726 
727  /* test different interface data, but different pointer */
728  /* raises ERROR_INVALID_HANDLE exception */
729  if (0)
730  {
731  static RPC_SERVER_INTERFACE server_if2 =
732  {
733  sizeof(RPC_SERVER_INTERFACE),
734  {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
735  {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
736  NULL,
737  0,
738  0,
739  0,
740  0,
741  0,
742  };
743  pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
744 
745  pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if2.InterfaceId, 0);
746  }
747 
748  binding = NULL;
750 
751  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
752  ok(binding != NULL, "binding is NULL\n");
753 
754  if (status == RPC_S_OK && binding != NULL)
755  {
756  unsigned char* string_binding = NULL;
757  unsigned char* object_uuid = NULL;
758  unsigned char* protseq = NULL;
759  unsigned char* network_address = NULL;
760  unsigned char* endpoint = NULL;
761  unsigned char* network_options = NULL;
762 
763  status = RpcBindingToStringBindingA(binding, &string_binding);
764  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
765  ok(string_binding != NULL, "string_binding is NULL\n");
766 
767  status = RpcStringBindingParseA(string_binding, &object_uuid, &protseq, &network_address, &endpoint, &network_options);
768  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
769  ok(protseq != NULL && *protseq != '\0', "protseq is %s\n", protseq);
770  ok(network_address != NULL && *network_address != '\0', "network_address is %s\n", network_address);
771 
772  todo_wine
773  {
774  ok(object_uuid != NULL && *object_uuid == '\0', "object_uuid is %s\n", object_uuid);
775  ok(endpoint != NULL && *endpoint == '\0', "endpoint is %s\n", endpoint);
776  ok(network_options != NULL && *network_options == '\0', "network_options is %s\n", network_options);
777  }
778 
779  RpcStringFreeA(&string_binding);
780  RpcStringFreeA(&object_uuid);
781  RpcStringFreeA(&protseq);
782  RpcStringFreeA(&network_address);
784  RpcStringFreeA(&network_options);
785  RpcBindingFree(&binding);
786  }
787 }
788 
789 void __cdecl s_get_numbers(int length, int size, pints_t n[])
790 {
791  int i;
792  for (i = 0; i < length; i++)
793  {
794  n[i].pi = midl_user_allocate(sizeof(*n[i].pi));
795  *n[i].pi = i;
796  n[i].ppi = NULL;
797  n[i].pppi = NULL;
798  }
799 }
800 
801 void __cdecl s_get_numbers_struct(numbers_struct_t **ns)
802 {
803  int i;
804  *ns = midl_user_allocate(FIELD_OFFSET(numbers_struct_t, numbers[5]));
805  if (!*ns) return;
806  (*ns)->length = 5;
807  (*ns)->size = 5;
808  for (i = 0; i < (*ns)->length; i++)
809  {
810  (*ns)->numbers[i].pi = NULL;
811  (*ns)->numbers[i].ppi = NULL;
812  (*ns)->numbers[i].pppi = NULL;
813  }
814  (*ns)->numbers[0].pi = midl_user_allocate(sizeof(*(*ns)->numbers[i].pi));
815  *(*ns)->numbers[0].pi = 5;
816 }
817 
818 void __cdecl s_full_pointer_test(int *a, int *b)
819 {
820  ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
821  ok(*b == 42, "Expected *b to be 42 instead of %d\n", *a);
822  ok(a == b, "Expected a (%p) to point to the same memory as b (%p)\n", a, b);
823 }
824 
826 {
827  ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
828  ok(b == NULL, "Expected b to be NULL instead of %p\n", b);
829 }
830 
831 void __cdecl s_stop(void)
832 {
833  if (!stop_wait_event)
834  {
835  ok(RPC_S_OK == RpcMgmtStopServerListening(NULL), "RpcMgmtStopServerListening\n");
836  ok(RPC_S_OK == RpcServerUnregisterIf(NULL, NULL, FALSE), "RpcServerUnregisterIf\n");
837  }
838  ok(SetEvent(stop_event), "SetEvent\n");
839  if (stop_wait_event)
840  {
841  DWORD ret;
843  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
844  }
845 }
846 
848 {
851 todo_wine
852  ok(status == RPC_S_UNKNOWN_MGR_TYPE, "got %u\n", status);
853 }
854 
855 void __cdecl s_ip_test(ipu_t *a)
856 {
857  STATSTG st;
858  HRESULT hr;
859 
860  hr = IStream_Stat(a->tagged_union.stream, &st, STATFLAG_NONAME);
861  ok(hr == S_OK, "got %#x\n", hr);
862 }
863 
865 {
866  return *a[0] + *a[1];
867 }
868 
869 int __cdecl s_sum_array_ptr(int (*a)[2])
870 {
871  return (*a)[0] + (*a)[1];
872 }
873 
874 static void
875 make_cmdline(char buffer[MAX_PATH], const char *test)
876 {
877  sprintf(buffer, "%s server %s", progname, test);
878 }
879 
880 static void
881 run_client(const char *test)
882 {
883  char cmdline[MAX_PATH];
886 
887  memset(&startup, 0, sizeof startup);
888  startup.cb = sizeof startup;
889 
891  ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
892  winetest_wait_child_process( info.hProcess );
893  ok(CloseHandle(info.hProcess), "CloseHandle\n");
894  ok(CloseHandle(info.hThread), "CloseHandle\n");
895 }
896 
897 static void
899 {
900  char string[] = "I am a string";
901  WCHAR wstring[] = {'I',' ','a','m',' ','a',' ','w','s','t','r','i','n','g', 0};
902  int f[5] = {1, 3, 0, -2, -4};
903  vector_t a = {1, 3, 7};
904  vector_t vec1 = {4, -2, 1}, vec2 = {-5, 2, 3}, *pvec2 = &vec2;
905  pvectors_t pvecs = {&vec1, &pvec2};
906  sp_inner_t spi = {42};
907  sp_t sp = {-13, &spi};
908  aligns_t aligns;
909  pints_t pints;
910  ptypes_t ptypes;
911  padded_t padded;
912  padded_t padded2[2];
913  bogus_t bogus;
914  int i1, i2, i3, *pi2, *pi3, **ppi3;
915  double u, v;
916  float s, t;
917  LONG q, r;
918  short h;
919  char c;
920  int x;
921  hyper y;
922  str_struct_t ss = {string};
923  wstr_struct_t ws = {wstring};
924  str_t str;
925  se_t se;
926  renum_t re;
927 
928  ok(int_return() == INT_CODE, "RPC int_return\n");
929 
930  ok(square(7) == 49, "RPC square\n");
931  x = sum(23, -4);
932  ok(x == 19, "RPC sum got %d\n", x);
933  c = sum_char(-23, 50);
934  ok(c == 27, "RPC sum_char got %d\n", (int)c);
935  h = sum_short(1122, -344);
936  ok(h == 778, "RPC sum_short got %d\n", (int)h);
937  x = sum_float(123.45, -32.2);
938  ok(x == 91, "RPC sum_float got %d\n", x);
939  x = sum_double_int(-78, 148.46);
940  ok(x == 70, "RPC sum_double_int got %d\n", x);
941  y = sum_hyper((hyper)0x12345678 << 16, (hyper)0x33557799 << 16);
942  ok(y == (hyper)0x4589ce11 << 16, "RPC hyper got %s\n", wine_dbgstr_longlong(y));
943  x = sum_hyper_int((hyper)0x24242424 << 16, -((hyper)0x24241212 << 16));
944  ok(x == 0x12120000, "RPC hyper_int got 0x%x\n", x);
945  x = sum_char_hyper( 12, ((hyper)0x42424242 << 32) | 0x33334444 );
946  ok(x == 0x33334450, "RPC char_hyper got 0x%x\n", x);
947 
948  x = 0;
949  square_out(11, &x);
950  ok(x == 121, "RPC square_out\n");
951 
952  x = 5;
953  square_ref(&x);
954  ok(x == 25, "RPC square_ref\n");
955 
956  ok(str_length(string) == strlen(string), "RPC str_length\n");
957  ok(str_t_length(string) == strlen(string), "RPC str_length\n");
958  ok(dot_self(&a) == 59, "RPC dot_self\n");
959 
960  ok(str_struct_len(&ss) == lstrlenA(string), "RPC str_struct_len\n");
961  ok(wstr_struct_len(&ws) == lstrlenW(wstring), "RPC str_struct_len\n");
962 
963  v = 0.0;
964  u = square_half(3.0, &v);
965  ok(u == 9.0, "RPC square_half\n");
966  ok(v == 1.5, "RPC square_half\n");
967 
968  t = 0.0f;
969  s = square_half_float(3.0f, &t);
970  ok(s == 9.0f, "RPC square_half_float\n");
971  ok(t == 1.5f, "RPC square_half_float\n");
972 
973  r = 0;
974  q = square_half_long(3, &r);
975  ok(q == 9, "RPC square_half_long\n");
976  ok(r == 1, "RPC square_half_long\n");
977 
978  i1 = 19;
979  i2 = -3;
980  i3 = -29;
981  pi2 = &i2;
982  pi3 = &i3;
983  ppi3 = &pi3;
984  pints.pi = &i1;
985  pints.ppi = &pi2;
986  pints.pppi = &ppi3;
987  ok(pints_sum(&pints) == -13, "RPC pints_sum\n");
988 
989  c = 10;
990  h = 3;
991  q = 14;
992  s = -5.0f;
993  u = 11.0;
994  ptypes.pc = &c;
995  ptypes.ps = &h;
996  ptypes.pl = &q;
997  ptypes.pf = &s;
998  ptypes.pd = &u;
999  ok(ptypes_sum(&ptypes) == 33.0, "RPC ptypes_sum\n");
1000 
1001  ok(dot_pvectors(&pvecs) == -21, "RPC dot_pvectors\n");
1002  ok(dot_copy_vectors(vec1, vec2) == -21, "RPC dot_copy_vectors\n");
1003  ok(sum_fixed_array(f) == -2, "RPC sum_fixed_array\n");
1004  ok(sum_sp(&sp) == 29, "RPC sum_sp\n");
1005 
1006  ok(enum_ord(E1) == 1, "RPC enum_ord\n");
1007  ok(enum_ord(E2) == 2, "RPC enum_ord\n");
1008  ok(enum_ord(E3) == 3, "RPC enum_ord\n");
1009  ok(enum_ord(E4) == 4, "RPC enum_ord\n");
1010 
1011  se.f = E2;
1012  check_se2(&se);
1013 
1014  memset(&aligns, 0, sizeof(aligns));
1015  aligns.c = 3;
1016  aligns.i = 4;
1017  aligns.s = 5;
1018  aligns.d = 6.0;
1019  ok(sum_aligns(&aligns) == 18.0, "RPC sum_aligns\n");
1020 
1021  padded.i = -3;
1022  padded.c = 8;
1023  ok(sum_padded(&padded) == 5, "RPC sum_padded\n");
1024  padded2[0].i = -5;
1025  padded2[0].c = 1;
1026  padded2[1].i = 3;
1027  padded2[1].c = 7;
1028  ok(sum_padded2(padded2) == 6, "RPC sum_padded2\n");
1029  padded2[0].i = -5;
1030  padded2[0].c = 1;
1031  padded2[1].i = 3;
1032  padded2[1].c = 7;
1033  ok(sum_padded_conf(padded2, 2) == 6, "RPC sum_padded_conf\n");
1034 
1035  i1 = 14;
1036  i2 = -7;
1037  i3 = -4;
1038  bogus.h.p1 = &i1;
1039  bogus.p2 = &i2;
1040  bogus.p3 = &i3;
1041  bogus.c = 9;
1042  ok(sum_bogus(&bogus) == 12, "RPC sum_bogus\n");
1043 
1044  check_null(NULL);
1045 
1046  str = get_filename();
1047  ok(!strcmp(str, __FILE__), "get_filename() returned %s instead of %s\n", str, __FILE__);
1049 
1050  x = echo_ranged_int(0,0,0);
1051  ok(x == 0, "echo_ranged_int() returned %d instead of 0\n", x);
1052  x = echo_ranged_int(10,20,100);
1053  ok(x == 100, "echo_ranged_int() returned %d instead of 100\n", x);
1054  x = echo_ranged_int2(40);
1055  ok(x == 40, "echo_ranged_int() returned %d instead of 40\n", x);
1056 
1057  if (!old_windows_version)
1058  {
1059  re = 0xdeadbeef;
1060  get_ranged_enum(&re);
1061  ok(re == RE3 ||
1062  broken(re == MAKELONG(re, 0xdead)), /* Win 8, Win 10 */
1063  "get_ranged_enum() returned %x instead of RE3\n", re);
1064  }
1065 }
1066 
1067 static void
1069 {
1070  encue_t eue;
1071  encu_t eu;
1072  unencu_t uneu;
1073  sun_t su;
1074  ipu_t ipu;
1075  LONG ref;
1076  int i;
1077 
1078  su.s = SUN_I;
1079  su.u.i = 9;
1080  ok(square_sun(&su) == 81.0, "RPC square_sun\n");
1081 
1082  su.s = SUN_F1;
1083  su.u.f = 5.0;
1084  ok(square_sun(&su) == 25.0, "RPC square_sun\n");
1085 
1086  su.s = SUN_F2;
1087  su.u.f = -2.0;
1088  ok(square_sun(&su) == 4.0, "RPC square_sun\n");
1089 
1090  su.s = SUN_PI;
1091  su.u.pi = &i;
1092  i = 11;
1093  ok(square_sun(&su) == 121.0, "RPC square_sun\n");
1094 
1095  eu.t = ENCU_I;
1096  eu.tagged_union.i = 7;
1097  ok(square_encu(&eu) == 49.0, "RPC square_encu\n");
1098 
1099  eu.t = ENCU_F;
1100  eu.tagged_union.f = 3.0;
1101  ok(square_encu(&eu) == 9.0, "RPC square_encu\n");
1102 
1103  uneu.i = 4;
1104  ok(square_unencu(ENCU_I, &uneu) == 16.0, "RPC square_unencu\n");
1105 
1106  uneu.f = 5.0;
1107  ok(square_unencu(ENCU_F, &uneu) == 25.0, "RPC square_unencu\n");
1108 
1109  eue.t = E1;
1110  eue.tagged_union.i1 = 8;
1111  ok(square_encue(&eue) == 64.0, "RPC square_encue\n");
1112 
1113  eue.t = E2;
1114  eue.tagged_union.f2 = 10.0;
1115  ok(square_encue(&eue) == 100.0, "RPC square_encue\n");
1116 
1118 
1119  CreateStreamOnHGlobal(NULL, TRUE, &ipu.tagged_union.stream);
1120  ip_test(&ipu);
1121  ref = IStream_Release(ipu.tagged_union.stream);
1122  ok(!ref, "got %u refs\n", ref);
1123 
1124  CoUninitialize();
1125 }
1126 
1127 static test_list_t *
1129 {
1130  test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
1131  n->t = TL_NULL;
1132  n->u.x = 0;
1133  return n;
1134 }
1135 
1136 static test_list_t *
1137 make_list(test_list_t *tail)
1138 {
1139  test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
1140  n->t = TL_LIST;
1141  n->u.tail = tail;
1142  return n;
1143 }
1144 
1145 static void
1146 free_list(test_list_t *list)
1147 {
1148  if (list->t == TL_LIST)
1149  free_list(list->u.tail);
1150  HeapFree(GetProcessHeap(), 0, list);
1151 }
1152 
1155 {
1156  return start + sizeof(int);
1157 }
1158 
1159 unsigned char * __RPC_USER
1160 puint_t_UserMarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
1161 {
1162  int n = atoi(*p);
1163  memcpy(buffer, &n, sizeof n);
1164  return buffer + sizeof n;
1165 }
1166 
1167 unsigned char * __RPC_USER
1168 puint_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
1169 {
1170  int n;
1171  memcpy(&n, buffer, sizeof n);
1172  *p = HeapAlloc(GetProcessHeap(), 0, 10);
1173  sprintf(*p, "%d", n);
1174  return buffer + sizeof n;
1175 }
1176 
1177 void __RPC_USER
1179 {
1180  HeapFree(GetProcessHeap(), 0, *p);
1181 }
1182 
1185 {
1186  return start + sizeof(struct wire_us);
1187 }
1188 
1189 unsigned char * __RPC_USER
1190 us_t_UserMarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1191 {
1192  struct wire_us wus;
1193  wus.x = atoi(pus->x);
1194  memcpy(buffer, &wus, sizeof wus);
1195  return buffer + sizeof wus;
1196 }
1197 
1198 unsigned char * __RPC_USER
1199 us_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1200 {
1201  struct wire_us wus;
1202  memcpy(&wus, buffer, sizeof wus);
1203  pus->x = HeapAlloc(GetProcessHeap(), 0, 10);
1204  sprintf(pus->x, "%d", wus.x);
1205  return buffer + sizeof wus;
1206 }
1207 
1208 void __RPC_USER
1210 {
1211  HeapFree(GetProcessHeap(), 0, pus->x);
1212 }
1213 
1216 {
1217  return start + FIELD_OFFSET(user_bstr_t, data[(*b)[-1]]);
1218 }
1219 
1220 unsigned char * __RPC_USER
1222 {
1223  wire_bstr_t wb = (wire_bstr_t) buffer;
1224  wb->n = (*b)[-1];
1225  memcpy(&wb->data, *b, wb->n * sizeof wb->data[0]);
1226  return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1227 }
1228 
1229 unsigned char * __RPC_USER
1231 {
1232  wire_bstr_t wb = (wire_bstr_t) buffer;
1233  short *data = HeapAlloc(GetProcessHeap(), 0, (wb->n + 1) * sizeof *data);
1234  data[0] = wb->n;
1235  memcpy(&data[1], wb->data, wb->n * sizeof data[1]);
1236  *b = &data[1];
1237  return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1238 }
1239 
1240 void __RPC_USER
1242 {
1243  HeapFree(GetProcessHeap(), 0, &((*b)[-1]));
1244 }
1245 
1246 static void
1248 {
1249  int a[] = {1, 2, 3, 4};
1250  char p1[] = "11";
1251  test_list_t *list = make_list(make_list(make_list(null_list())));
1252  test_us_t tus = {{p1}};
1253  int *pa[4];
1254  puints_t pus;
1255  cpuints_t cpus;
1256  short bstr_data[] = { 5, 'H', 'e', 'l', 'l', 'o' };
1257  bstr_t bstr = &bstr_data[1], bstr2;
1258  name_t name;
1259  void *buffer;
1260  int *pa2;
1261  s123_t *s123;
1262  int val = 42;
1263 
1264  ok(test_list_length(list) == 3, "RPC test_list_length\n");
1265  ok(square_puint(p1) == 121, "RPC square_puint\n");
1266  pus.n = 4;
1267  pus.ps = HeapAlloc(GetProcessHeap(), 0, pus.n * sizeof pus.ps[0]);
1268  pus.ps[0] = xstrdup("5");
1269  pus.ps[1] = xstrdup("6");
1270  pus.ps[2] = xstrdup("7");
1271  pus.ps[3] = xstrdup("8");
1272  ok(sum_puints(&pus) == 26, "RPC sum_puints\n");
1273  HeapFree(GetProcessHeap(), 0, pus.ps[0]);
1274  HeapFree(GetProcessHeap(), 0, pus.ps[1]);
1275  HeapFree(GetProcessHeap(), 0, pus.ps[2]);
1276  HeapFree(GetProcessHeap(), 0, pus.ps[3]);
1277  HeapFree(GetProcessHeap(), 0, pus.ps);
1278  cpus.n = 4;
1279  cpus.ps = HeapAlloc(GetProcessHeap(), 0, cpus.n * sizeof cpus.ps[0]);
1280  cpus.ps[0] = xstrdup("5");
1281  cpus.ps[1] = xstrdup("6");
1282  cpus.ps[2] = xstrdup("7");
1283  cpus.ps[3] = xstrdup("8");
1284  ok(sum_cpuints(&cpus) == 26, "RPC sum_puints\n");
1285  HeapFree(GetProcessHeap(), 0, cpus.ps[0]);
1286  HeapFree(GetProcessHeap(), 0, cpus.ps[1]);
1287  HeapFree(GetProcessHeap(), 0, cpus.ps[2]);
1288  HeapFree(GetProcessHeap(), 0, cpus.ps[3]);
1289  HeapFree(GetProcessHeap(), 0, cpus.ps);
1290  ok(square_test_us(&tus) == 121, "RPC square_test_us\n");
1291 
1292  pa[0] = &a[0];
1293  pa[1] = &a[1];
1294  pa[2] = &a[2];
1295  ok(sum_parr(pa) == 6, "RPC sum_parr\n");
1296 
1297  pa[0] = &a[0];
1298  pa[1] = &a[1];
1299  pa[2] = &a[2];
1300  pa[3] = &a[3];
1301  ok(sum_pcarr(pa, 4) == 10, "RPC sum_pcarr\n");
1302 
1303  ok(hash_bstr(bstr) == s_hash_bstr(bstr), "RPC hash_bstr_data\n");
1304 
1305  get_a_bstr(&bstr);
1306  s_get_a_bstr(&bstr2);
1307  ok(!lstrcmpW((LPCWSTR)bstr, (LPCWSTR)bstr2), "bstr mismatch\n");
1308  HeapFree(GetProcessHeap(), 0, bstr - 1);
1309  HeapFree(GetProcessHeap(), 0, bstr2 - 1);
1310 
1311  free_list(list);
1312 
1313  if (!old_windows_version)
1314  {
1315  int n;
1316  str_array_t names;
1317  wstr_array_t namesw;
1318 
1319  name.size = 10;
1321  get_name(&name);
1322  ok(name.name == buffer, "[in,out] pointer should have stayed as %p but instead changed to %p\n", name.name, buffer);
1323  ok(!strcmp(name.name, "Jeremy Wh"), "name didn't unmarshall properly, expected \"Jeremy Wh\", but got \"%s\"\n", name.name);
1325 
1326  n = -1;
1327  names = NULL;
1328  get_names(&n, &names);
1329  ok(n == 2, "expected 2, got %d\n", n);
1330  ok(!strcmp(names[0], "Hello"), "expected Hello, got %s\n", names[0]);
1331  ok(!strcmp(names[1], "World!"), "expected World!, got %s\n", names[1]);
1332  MIDL_user_free(names[0]);
1333  MIDL_user_free(names[1]);
1335 
1336  n = -1;
1337  namesw = NULL;
1338  get_namesw(&n, &namesw);
1339  ok(n == 2, "expected 2, got %d\n", n);
1340  ok(!lstrcmpW(namesw[0], helloW), "expected Hello, got %s\n", wine_dbgstr_w(namesw[0]));
1341  ok(!lstrcmpW(namesw[1], worldW), "expected World!, got %s\n", wine_dbgstr_w(namesw[1]));
1342  MIDL_user_free(namesw[0]);
1343  MIDL_user_free(namesw[1]);
1344  MIDL_user_free(namesw);
1345  }
1346 
1347  pa2 = a;
1348  ok(sum_pcarr2(4, &pa2) == 10, "RPC sum_pcarr2\n");
1349 
1350  s123 = get_s123();
1351  ok(s123->f1 == 1 && s123->f2 == 2 && s123->f3 == 3, "RPC get_s123\n");
1352  MIDL_user_free(s123);
1353 
1354  full_pointer_test(&val, &val);
1355  full_pointer_null_test(&val, NULL);
1356 }
1357 
1358 static int
1360 {
1361  int i, j;
1362  for (i = 0; i < dc->n; ++i)
1363  for (j = 0; j < dc->a[i]->n; ++j)
1364  if (dc->a[i]->a[j] != j + 1)
1365  return FALSE;
1366  return TRUE;
1367 }
1368 
1369 static void
1371 {
1372  int i;
1373  for (i = 0; i < dc->n; ++i)
1374  MIDL_user_free(dc->a[i]);
1375  MIDL_user_free(dc);
1376 }
1377 
1378 static void
1380 {
1381  int m[2][3][4] =
1382  {
1383  {{1, 2, 3, 4}, {-1, -3, -5, -7}, {0, 2, 4, 6}},
1384  {{1, -2, 3, -4}, {2, 3, 5, 7}, {-4, -1, -14, 4114}}
1385  };
1386  int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1387  int c2[] = {10, 100, 200};
1388  int c3[20];
1389  vector_t vs[2] = {{1, -2, 3}, {4, -5, -6}};
1390  cps_t cps;
1391  cpsc_t cpsc;
1392  cs_t *cs;
1393  int n;
1394  int ca[5] = {1, -2, 3, -4, 5};
1395  int tmp[10];
1396  doub_carr_t *dc;
1397  int *pi;
1398  pints_t api[5];
1399  numbers_struct_t *ns;
1400  refpint_t rpi[5];
1401  int i0 = 1, i1 = 2, *ptr_array[2] = {&i0, &i1}, array[2] = {3, 4};
1402 
1403  if (!old_windows_version)
1404  {
1405  const char str1[25] = "Hello";
1406  ok(cstr_length(str1, sizeof str1) == strlen(str1), "RPC cstr_length\n");
1407  }
1408 
1409  ok(sum_fixed_int_3d(m) == 4116, "RPC sum_fixed_int_3d\n");
1410 
1411  ok(sum_conf_array(c, 10) == 45, "RPC sum_conf_array\n");
1412  ok(sum_conf_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1413  ok(sum_conf_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1414  ok(sum_conf_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1415 
1416  ok(sum_conf_ptr_by_conf_ptr(1, c2, c) == 45, "RPC sum_conf_ptr_by_conf_ptr\n");
1417  ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 345, "RPC sum_conf_ptr_by_conf_ptr\n");
1418  c2[0] = 0;
1419  ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 300, "RPC sum_conf_ptr_by_conf_ptr\n");
1420 
1421  ok(sum_unique_conf_array(ca, 4) == -2, "RPC sum_unique_conf_array\n");
1422  ok(sum_unique_conf_ptr(ca, 5) == 3, "RPC sum_unique_conf_array\n");
1423  ok(sum_unique_conf_ptr(NULL, 10) == 0, "RPC sum_unique_conf_array\n");
1424 
1425  get_number_array(c3, &n);
1426  ok(n == 10, "RPC get_num_array\n");
1427  for (; n > 0; n--)
1428  ok(c3[n-1] == c[n-1], "get_num_array returned wrong value %d @ %d\n",
1429  c3[n-1], n);
1430  ok(sum_var_array(c, 10) == 45, "RPC sum_conf_array\n");
1431  ok(sum_var_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1432  ok(sum_var_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1433  ok(sum_var_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1434 
1435  ok(dot_two_vectors(vs) == -4, "RPC dot_two_vectors\n");
1436  cs = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(cs_t, ca[5]));
1437  cs->n = 5;
1438  cs->ca[0] = 3;
1439  cs->ca[1] = 5;
1440  cs->ca[2] = -2;
1441  cs->ca[3] = -1;
1442  cs->ca[4] = -4;
1443  ok(sum_cs(cs) == 1, "RPC sum_cs\n");
1444  HeapFree(GetProcessHeap(), 0, cs);
1445 
1446  n = 5;
1447  cps.pn = &n;
1448  cps.ca1 = &c[2];
1449  cps.n = 3;
1450  cps.ca2 = &c[3];
1451  ok(sum_cps(&cps) == 53, "RPC sum_cps\n");
1452 
1453  cpsc.a = 4;
1454  cpsc.b = 5;
1455  cpsc.c = 1;
1456  cpsc.ca = c;
1457  ok(sum_cpsc(&cpsc) == 6, "RPC sum_cpsc\n");
1458  cpsc.a = 4;
1459  cpsc.b = 5;
1460  cpsc.c = 0;
1461  cpsc.ca = c;
1462  ok(sum_cpsc(&cpsc) == 10, "RPC sum_cpsc\n");
1463 
1464  cpsc.ca = NULL;
1465  ok(get_cpsc(5, &cpsc) == 45, "RPC sum_cpsc\n");
1466  ok( cpsc.a == 10, "RPC get_cpsc %u\n", cpsc.a );
1467  for (n = 0; n < 10; n++) ok( cpsc.ca[n] == n, "RPC get_cpsc[%d] = %d\n", n, cpsc.ca[n] );
1468 
1469  memset( tmp, 0x33, sizeof(tmp) );
1470  cpsc.ca = tmp;
1471  ok(get_cpsc(4, &cpsc) == 28, "RPC sum_cpsc\n");
1472  ok( cpsc.a == 8, "RPC get_cpsc %u\n", cpsc.a );
1473  ok( cpsc.ca == tmp, "RPC get_cpsc %p/%p\n", cpsc.ca, tmp );
1474  for (n = 0; n < 8; n++) ok( cpsc.ca[n] == n, "RPC get_cpsc[%d] = %d\n", n, cpsc.ca[n] );
1475 
1476  ok(sum_toplev_conf_2n(c, 3) == 15, "RPC sum_toplev_conf_2n\n");
1477  ok(sum_toplev_conf_cond(c, 5, 6, 1) == 10, "RPC sum_toplev_conf_cond\n");
1478  ok(sum_toplev_conf_cond(c, 5, 6, 0) == 15, "RPC sum_toplev_conf_cond\n");
1479 
1480  dc = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_t, a[2]));
1481  dc->n = 2;
1482  dc->a[0] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[3]));
1483  dc->a[0]->n = 3;
1484  dc->a[0]->a[0] = 5;
1485  dc->a[0]->a[1] = 1;
1486  dc->a[0]->a[2] = 8;
1487  dc->a[1] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[2]));
1488  dc->a[1]->n = 2;
1489  dc->a[1]->a[0] = 2;
1490  dc->a[1]->a[1] = 3;
1491  ok(sum_doub_carr(dc) == 19, "RPC sum_doub_carr\n");
1492  HeapFree(GetProcessHeap(), 0, dc->a[0]);
1493  HeapFree(GetProcessHeap(), 0, dc->a[1]);
1494  HeapFree(GetProcessHeap(), 0, dc);
1495 
1496  dc = NULL;
1497  make_pyramid_doub_carr(4, &dc);
1498  ok(check_pyramid_doub_carr(dc), "RPC make_pyramid_doub_carr\n");
1500 
1501  ok(sum_L1_norms(2, vs) == 21, "RPC sum_L1_norms\n");
1502 
1503  memset(api, 0, sizeof(api));
1504  pi = HeapAlloc(GetProcessHeap(), 0, sizeof(*pi));
1505  *pi = -1;
1506  api[0].pi = pi;
1507  get_numbers(1, 1, api);
1508  ok(api[0].pi == pi, "RPC conformant varying array [out] pointer changed from %p to %p\n", pi, api[0].pi);
1509  ok(*api[0].pi == 0, "pi unmarshalled incorrectly %d\n", *api[0].pi);
1510 
1511  if (!old_windows_version)
1512  {
1513  ns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(numbers_struct_t, numbers[5]));
1514  ns->length = 5;
1515  ns->size = 5;
1516  ns->numbers[0].pi = pi;
1517  get_numbers_struct(&ns);
1518  ok(ns->numbers[0].pi == pi, "RPC conformant varying struct embedded pointer changed from %p to %p\n", pi, ns->numbers[0].pi);
1519  ok(*ns->numbers[0].pi == 5, "pi unmarshalled incorrectly %d\n", *ns->numbers[0].pi);
1520  HeapFree(GetProcessHeap(), 0, ns);
1521  }
1522  HeapFree(GetProcessHeap(), 0, pi);
1523 
1524  pi = HeapAlloc(GetProcessHeap(), 0, 5 * sizeof(*pi));
1525  pi[0] = 3; rpi[0] = &pi[0];
1526  pi[1] = 5; rpi[1] = &pi[1];
1527  pi[2] = -2; rpi[2] = &pi[2];
1528  pi[3] = -1; rpi[3] = &pi[3];
1529  pi[4] = -4; rpi[4] = &pi[4];
1530  ok(sum_complex_array(5, rpi) == 1, "RPC sum_complex_array\n");
1531  HeapFree(GetProcessHeap(), 0, pi);
1532 
1533  ok(sum_ptr_array(ptr_array) == 3, "RPC sum_ptr_array\n");
1534  ok(sum_array_ptr(&array) == 7, "RPC sum_array_ptr\n");
1535 }
1536 
1537 void __cdecl s_authinfo_test(unsigned int protseq, int secure)
1538 {
1539  RPC_BINDING_HANDLE binding;
1541  ULONG level, authnsvc;
1542  RPC_AUTHZ_HANDLE privs;
1543  unsigned char *principal;
1544 
1545  binding = I_RpcGetCurrentCallHandle();
1546  ok(binding != NULL, "I_RpcGetCurrentCallHandle returned NULL\n");
1547 
1548  level = authnsvc = 0xdeadbeef;
1549  privs = (RPC_AUTHZ_HANDLE)0xdeadbeef;
1550  principal = (unsigned char *)0xdeadbeef;
1551 
1552  if (secure || protseq == RPC_PROTSEQ_LRPC)
1553  {
1554  status = RpcBindingInqAuthClientA(binding, &privs, &principal, &level, &authnsvc, NULL);
1556  {
1557  win_skip("RpcBindingInqAuthClientA not supported\n");
1558  return;
1559  }
1560  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1561  ok(privs != (RPC_AUTHZ_HANDLE)0xdeadbeef, "privs unchanged\n");
1562  ok(principal != (unsigned char *)0xdeadbeef, "principal unchanged\n");
1563  if (protseq != RPC_PROTSEQ_LRPC)
1564  {
1565  todo_wine
1566  ok(principal != NULL, "NULL principal\n");
1567  }
1568  if (protseq == RPC_PROTSEQ_LRPC && principal)
1569  {
1570  int len;
1571  char *spn;
1572 
1573  len = WideCharToMultiByte(CP_ACP, 0, (const WCHAR *)privs, -1, NULL, 0, NULL, NULL);
1574  spn = HeapAlloc( GetProcessHeap(), 0, len );
1575  WideCharToMultiByte(CP_ACP, 0, (const WCHAR *)privs, -1, spn, len, NULL, NULL);
1576 
1577  ok(!strcmp(domain_and_user, spn), "expected %s got %s\n", domain_and_user, spn);
1578  HeapFree( GetProcessHeap(), 0, spn );
1579  }
1580  ok(level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY, "level unchanged\n");
1581  ok(authnsvc == RPC_C_AUTHN_WINNT, "authnsvc unchanged\n");
1582  RpcStringFreeA(&principal);
1583 
1584  status = RpcBindingInqAuthClientA(NULL, &privs, &principal, &level, &authnsvc, NULL);
1585  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1586  RpcStringFreeA(&principal);
1587 
1588  status = RpcBindingInqAuthClientExA(NULL, &privs, &principal, &level, &authnsvc, NULL, 0);
1589  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1590  RpcStringFreeA(&principal);
1591 
1593  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1594  status = RpcRevertToSelf();
1595  ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1596 
1597  }
1598  else
1599  {
1600  status = RpcBindingInqAuthClientA(binding, &privs, &principal, &level, &authnsvc, NULL);
1601  ok(status == RPC_S_BINDING_HAS_NO_AUTH, "expected RPC_S_BINDING_HAS_NO_AUTH got %u\n", status);
1602  ok(privs == (RPC_AUTHZ_HANDLE)0xdeadbeef, "got %p\n", privs);
1603  ok(principal == (unsigned char *)0xdeadbeef, "got %s\n", principal);
1604  ok(level == 0xdeadbeef, "got %u\n", level);
1605  ok(authnsvc == 0xdeadbeef, "got %u\n", authnsvc);
1606  }
1607 }
1608 
1609 static void
1611 {
1612  basic_tests();
1613  union_tests();
1614  pointer_tests();
1615  array_tests();
1616  context_handle_test();
1617 }
1618 
1619 static void
1621 {
1623  RPC_SECURITY_QOS qos;
1624 
1625  qos.Version = 1;
1629 
1630  status = pRpcBindingSetAuthInfoExA(handle, (RPC_CSTR)domain_and_user, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
1631  RPC_C_AUTHN_WINNT, NULL, 0, &qos);
1632  ok(status == RPC_S_OK, "RpcBindingSetAuthInfoExA failed %d\n", status);
1633 }
1634 
1635 #define test_is_server_listening(a,b) _test_is_server_listening(__LINE__,a,b)
1636 static void _test_is_server_listening(unsigned line, RPC_BINDING_HANDLE binding, RPC_STATUS expected_status)
1637 {
1639  status = RpcMgmtIsServerListening(binding);
1640  ok_(__FILE__,line)(status == expected_status, "RpcMgmtIsServerListening returned %u, expected %u\n",
1641  status, expected_status);
1642 }
1643 
1644 #define test_is_server_listening2(a,b,c) _test_is_server_listening2(__LINE__,a,b,c)
1645 static void _test_is_server_listening2(unsigned line, RPC_BINDING_HANDLE binding, RPC_STATUS expected_status,
1646  RPC_STATUS expected_status2)
1647 {
1649  status = RpcMgmtIsServerListening(binding);
1650  ok_(__FILE__,line)(status == expected_status || status == expected_status2,
1651  "RpcMgmtIsServerListening returned %u, expected %u or %u\n",
1652  status, expected_status, expected_status2);
1653 }
1654 
1655 static void
1656 client(const char *test)
1657 {
1658  static unsigned char iptcp[] = "ncacn_ip_tcp";
1659  static unsigned char np[] = "ncacn_np";
1660  static unsigned char ncalrpc[] = "ncalrpc";
1661  static unsigned char address[] = "127.0.0.1";
1662  static unsigned char address_np[] = "\\\\.";
1663  static unsigned char port[] = PORT;
1664  static unsigned char pipe[] = PIPE;
1665  static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1666 
1667  unsigned char *binding;
1668 
1669  if (strcmp(test, "tcp_basic") == 0)
1670  {
1671  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
1672  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1673 
1674  run_tests();
1675  authinfo_test(RPC_PROTSEQ_TCP, 0);
1677 
1678  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1679  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1680  }
1681  else if (strcmp(test, "tcp_secure") == 0)
1682  {
1683  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
1684  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1685 
1686  set_auth_info(IServer_IfHandle);
1687  authinfo_test(RPC_PROTSEQ_TCP, 1);
1688  test_is_server_listening(IServer_IfHandle, RPC_S_ACCESS_DENIED);
1689 
1690  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1691  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1692  }
1693  else if (strcmp(test, "ncalrpc_basic") == 0)
1694  {
1695  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1696  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1697 
1698  run_tests(); /* can cause RPC_X_BAD_STUB_DATA exception */
1699  authinfo_test(RPC_PROTSEQ_LRPC, 0);
1700  test_is_server_listening(IServer_IfHandle, RPC_S_OK);
1701 
1702  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1703  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1704  }
1705  else if (strcmp(test, "ncalrpc_autolisten") == 0)
1706  {
1707  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1708  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1709 
1710  run_tests();
1711  authinfo_test(RPC_PROTSEQ_LRPC, 0);
1712 todo_wine
1713  test_is_server_listening(IServer_IfHandle, RPC_S_NOT_LISTENING);
1714 
1715  stop_autolisten();
1716  ok(int_return() == INT_CODE, "RPC int_return\n");
1717 
1718  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1719  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1720  }
1721  else if (strcmp(test, "ncalrpc_secure") == 0)
1722  {
1723  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1724  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1725 
1726  set_auth_info(IServer_IfHandle);
1727  authinfo_test(RPC_PROTSEQ_LRPC, 1);
1728  test_is_server_listening(IServer_IfHandle, RPC_S_OK);
1729 
1730  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1731  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1732  }
1733  else if (strcmp(test, "np_basic") == 0)
1734  {
1735  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, np, address_np, pipe, NULL, &binding), "RpcStringBindingCompose\n");
1736  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1737 
1738  test_is_server_listening(IServer_IfHandle, RPC_S_OK);
1739  run_tests();
1740  authinfo_test(RPC_PROTSEQ_NMP, 0);
1741  test_is_server_listening(IServer_IfHandle, RPC_S_OK);
1742  stop();
1743  test_is_server_listening(IServer_IfHandle, RPC_S_NOT_LISTENING);
1744 
1745  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
1746  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1747  }
1748 }
1749 
1750 static void
1751 server(void)
1752 {
1753  static unsigned char iptcp[] = "ncacn_ip_tcp";
1754  static unsigned char port[] = PORT;
1755  static unsigned char np[] = "ncacn_np";
1756  static unsigned char pipe[] = PIPE;
1757  static unsigned char ncalrpc[] = "ncalrpc";
1758  static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1759  RPC_STATUS status, iptcp_status, np_status, ncalrpc_status;
1760  DWORD ret;
1761 
1762  /* needed for tests involving interface pointers */
1764 
1765  iptcp_status = RpcServerUseProtseqEpA(iptcp, 20, port, NULL);
1766  ok(iptcp_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_ip_tcp) failed with status %d\n", iptcp_status);
1767 
1768  ncalrpc_status = RpcServerUseProtseqEpA(ncalrpc, 0, guid, NULL);
1769  ok(ncalrpc_status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", ncalrpc_status);
1770 
1771  np_status = RpcServerUseProtseqEpA(np, 0, pipe, NULL);
1772  if (np_status == RPC_S_PROTSEQ_NOT_SUPPORTED)
1773  skip("Protocol sequence ncacn_np is not supported\n");
1774  else
1775  ok(np_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", np_status);
1776 
1777  if (pRpcServerRegisterIfEx)
1778  {
1779  trace("Using RpcServerRegisterIfEx\n");
1780  status = pRpcServerRegisterIfEx(s_IServer_v0_0_s_ifspec, NULL, NULL,
1783  }
1784  else
1785  status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
1786  ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
1788  status = RpcServerListen(1, 20, TRUE);
1789  ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
1792  ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
1793 
1794  if (iptcp_status == RPC_S_OK)
1795  run_client("tcp_basic");
1796  else
1797  skip("tcp tests skipped due to earlier failure\n");
1798 
1799  if (ncalrpc_status == RPC_S_OK)
1800  {
1801  run_client("ncalrpc_basic");
1802 
1803  /* we don't need to register RPC_C_AUTHN_WINNT for ncalrpc */
1804  run_client("ncalrpc_secure");
1805  }
1806  else
1807  skip("lrpc tests skipped due to earlier failure\n");
1808 
1809  if (np_status == RPC_S_OK)
1810  run_client("np_basic");
1811  else
1812  {
1813  skip("np_basic tests skipped due to earlier failure\n");
1814  /* np client is what signals stop_event, so bail out if we didn't run do it */
1815  return;
1816  }
1817 
1819  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
1820  /* if the stop event didn't fire then RpcMgmtWaitServerListen will wait
1821  * forever, so don't bother calling it in this case */
1822  if (ret == WAIT_OBJECT_0)
1823  {
1825  ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
1826  }
1827 
1829  stop_event = NULL;
1830 
1831  if (pRpcServerRegisterIfEx)
1832  {
1833  status = pRpcServerRegisterIfEx(s_IServer_v0_0_s_ifspec, NULL, NULL,
1836  ok(status == RPC_S_OK, "RpcServerRegisterIf() failed: %u\n", status);
1837 
1838  run_client("ncalrpc_autolisten");
1839 
1840  status = RpcServerUnregisterIf(s_IServer_v0_0_s_ifspec, NULL, TRUE);
1841  ok(status == RPC_S_OK, "RpcServerUnregisterIf() failed: %u\n", status);
1842  }
1843 
1844  CoUninitialize();
1845 }
1846 
1848 {
1850 
1851  status = RpcBindingFromStringBindingA(binding, &IServer_IfHandle);
1852  ok(status == RPC_S_OK, "RpcBindingFromStringBinding\n");
1853 
1854  test_is_server_listening(IServer_IfHandle, RPC_S_OK);
1855  stop();
1856  trace("stopped\n");
1857 
1858  status = RpcBindingFree(&IServer_IfHandle);
1859  ok(status == RPC_S_OK, "RpcBindingFree\n");
1860  return 0;
1861 }
1862 
1864 {
1866 
1867  trace("waiting\n");
1869  ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
1870  trace("done\n");
1871 
1872  return 0;
1873 }
1874 
1875 static void test_stop_wait_for_call(unsigned char *binding)
1876 {
1877  HANDLE client_thread, wait_listen_thread;
1879  DWORD ret;
1880 
1881  status = RpcServerListen(1, 20, TRUE);
1882  ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
1884 
1886  ok(stop_wait_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
1888  ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
1889 
1890  wait_listen_thread = CreateThread(NULL, 0, wait_listen_proc, 0, 0, NULL);
1891  ok(wait_listen_thread != NULL, "CreateThread failed\n");
1892 
1893  client_thread = CreateThread(NULL, 0, listen_test_client_thread, binding, 0, NULL);
1894  ok(client_thread != NULL, "CreateThread failed\n");
1895  CloseHandle(client_thread);
1896 
1898  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
1899 
1901  ok(status == RPC_S_OK, "RpcMgmtStopServerListening\n");
1903 
1904  ret = WaitForSingleObject(wait_listen_thread, 500);
1905  ok(WAIT_TIMEOUT == ret, "WaitForSingleObject\n");
1906 
1908 
1909  ret = WaitForSingleObject(wait_listen_thread, 10000);
1910  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject returned %u\n", ret);
1911 
1912  CloseHandle(wait_listen_thread);
1913 
1917  stop_event = NULL;
1918 }
1919 
1920 static void test_server_listening(void)
1921 {
1922  static unsigned char np[] = "ncacn_np";
1923  static unsigned char address_np[] = "\\\\.";
1924  static unsigned char pipe[] = PIPE "listen_test";
1925  static unsigned char ncalrpc[] = "ncalrpc";
1926  static unsigned char guid[] = "00000000-4114-0704-2302-000000000000";
1927  unsigned char *binding;
1929 
1930  status = RpcServerUseProtseqEpA(np, 0, pipe, NULL);
1931  ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", status);
1932 
1933  status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
1934  ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
1935 
1937  status = RpcServerListen(1, 20, TRUE);
1938  ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
1940 
1941  status = RpcServerListen(1, 20, TRUE);
1942  ok(status == RPC_S_ALREADY_LISTENING, "RpcServerListen failed with status %d\n", status);
1943 
1945  ok(status == RPC_S_OK, "RpcMgmtStopServerListening\n");
1947 
1949  ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
1950 
1952  ok(status == RPC_S_NOT_LISTENING, "RpcMgmtWaitServerListening failed with status %d\n", status);
1953 
1954  /* test that server stop waits for a call in progress */
1955  status = RpcStringBindingComposeA(NULL, np, address_np, pipe, NULL, &binding);
1956  ok(status == RPC_S_OK, "RpcStringBindingCompose\n");
1957 
1958  test_stop_wait_for_call(binding);
1959 
1960  status = RpcStringFreeA(&binding);
1961  ok(status == RPC_S_OK, "RpcStringFree\n");
1962 
1963  /* repeat the test using ncalrpc */
1964  status = RpcServerUseProtseqEpA(ncalrpc, 0, guid, NULL);
1965  ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", status);
1966 
1967  status = RpcStringBindingComposeA(NULL, ncalrpc, NULL, guid, NULL, &binding);
1968  ok(status == RPC_S_OK, "RpcStringBindingCompose\n");
1969 
1970  test_stop_wait_for_call(binding);
1971 
1972  status = RpcStringFreeA(&binding);
1973  ok(status == RPC_S_OK, "RpcStringFree\n");
1974 }
1975 
1977 {
1978  SECURITY_ATTRIBUTES sec_attr = { sizeof(sec_attr), NULL, TRUE };
1979  HANDLE ready_event;
1980  char cmdline[MAX_PATH];
1983  DWORD ret;
1984 
1985  memset(&startup, 0, sizeof startup);
1986  startup.cb = sizeof startup;
1987 
1988  ready_event = CreateEventW(&sec_attr, TRUE, FALSE, NULL);
1989  ok(ready_event != NULL, "CreateEvent failed: %u\n", GetLastError());
1990 
1991  sprintf(cmdline, "%s server run %lx", progname, (UINT_PTR)ready_event);
1992  trace("running server process...\n");
1993  ok(CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
1994  ret = WaitForSingleObject(ready_event, 10000);
1995  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
1996 
1997  ok(CloseHandle(info.hThread), "CloseHandle\n");
1998  ok(CloseHandle(ready_event), "CloseHandle\n");
1999  return info.hProcess;
2000 }
2001 
2002 static void run_server(HANDLE ready_event)
2003 {
2004  static unsigned char np[] = "ncacn_np";
2005  static unsigned char pipe[] = PIPE "term_test";
2007  BOOL ret;
2008 
2009  status = RpcServerUseProtseqEpA(np, 0, pipe, NULL);
2010  ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", status);
2011 
2012  status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
2013  ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
2014 
2016  status = RpcServerListen(1, 20, TRUE);
2017  ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
2018 
2020  ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
2021 
2022  ret = SetEvent(ready_event);
2023  ok(ret, "SetEvent failed: %u\n", GetLastError());
2024 
2026  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
2027 
2029  ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
2030 
2032  stop_event = NULL;
2033 }
2034 
2036 {
2037  basic_tests();
2038  return 0;
2039 }
2040 
2041 static void test_reconnect(void)
2042 {
2043  static unsigned char np[] = "ncacn_np";
2044  static unsigned char address_np[] = "\\\\.";
2045  static unsigned char pipe[] = PIPE "term_test";
2046  unsigned char *binding;
2047  HANDLE threads[32];
2048  HANDLE server_process;
2049  unsigned i;
2050  DWORD ret;
2051 
2052  server_process = create_server_process();
2053 
2054  ok(RPC_S_OK == RpcStringBindingComposeA(NULL, np, address_np, pipe, NULL, &binding), "RpcStringBindingCompose\n");
2055  ok(RPC_S_OK == RpcBindingFromStringBindingA(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
2056 
2057  for (i = 0; i < ARRAY_SIZE(threads); i++)
2058  {
2060  ok(threads[i] != NULL, "CreateThread failed: %u\n", GetLastError());
2061  }
2062 
2063  for (i = 0; i < ARRAY_SIZE(threads); i++)
2064  {
2065  ret = WaitForSingleObject(threads[i], 10000);
2066  ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
2067  CloseHandle(threads[i]);
2068  }
2069 
2070  stop();
2071 
2072  winetest_wait_child_process(server_process);
2073  ok(CloseHandle(server_process), "CloseHandle\n");
2074 
2075  /* create new server, rpcrt4 will connect to it once sending to existing connection fails
2076  * that current connection is broken. */
2077  server_process = create_server_process();
2078  basic_tests();
2079  stop();
2080 
2081  winetest_wait_child_process(server_process);
2082  ok(CloseHandle(server_process), "CloseHandle\n");
2083 
2084  ok(RPC_S_OK == RpcStringFreeA(&binding), "RpcStringFree\n");
2085  ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
2086 }
2087 
2089 {
2090  HANDLE token;
2092  {
2094  DWORD size;
2095  BOOL ret;
2096 
2098  CloseHandle( token );
2099  return (ret && type == TokenElevationTypeFull);
2100  }
2101  return FALSE;
2102 }
2103 
2105 {
2106  HRESULT hr, init;
2107  INetFwMgr *mgr = NULL;
2108  INetFwPolicy *policy = NULL;
2110  VARIANT_BOOL enabled = VARIANT_FALSE;
2111 
2113 
2114  hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
2115  (void **)&mgr );
2116  ok( hr == S_OK, "got %08x\n", hr );
2117  if (hr != S_OK) goto done;
2118 
2119  hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
2120  ok( hr == S_OK, "got %08x\n", hr );
2121  if (hr != S_OK) goto done;
2122 
2123  hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
2124  if (hr != S_OK) goto done;
2125 
2126  hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
2127  ok( hr == S_OK, "got %08x\n", hr );
2128 
2129 done:
2130  if (policy) INetFwPolicy_Release( policy );
2131  if (profile) INetFwProfile_Release( profile );
2132  if (mgr) INetFwMgr_Release( mgr );
2133  if (SUCCEEDED( init )) CoUninitialize();
2134  return (enabled == VARIANT_TRUE);
2135 }
2136 
2138 {
2141 };
2142 
2144 {
2145  static const WCHAR testW[] = {'r','p','c','r','t','4','_','t','e','s','t',0};
2146  HRESULT hr, init;
2147  INetFwMgr *mgr = NULL;
2148  INetFwPolicy *policy = NULL;
2153 
2155  {
2156  SysFreeString( image );
2157  return E_FAIL;
2158  }
2160 
2161  hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
2162  (void **)&mgr );
2163  ok( hr == S_OK, "got %08x\n", hr );
2164  if (hr != S_OK) goto done;
2165 
2166  hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
2167  ok( hr == S_OK, "got %08x\n", hr );
2168  if (hr != S_OK) goto done;
2169 
2170  hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
2171  if (hr != S_OK) goto done;
2172 
2173  hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
2174  ok( hr == S_OK, "got %08x\n", hr );
2175  if (hr != S_OK) goto done;
2176 
2177  hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
2178  &IID_INetFwAuthorizedApplication, (void **)&app );
2179  ok( hr == S_OK, "got %08x\n", hr );
2180  if (hr != S_OK) goto done;
2181 
2182  hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
2183  if (hr != S_OK) goto done;
2184 
2185  name = SysAllocString( testW );
2186  hr = INetFwAuthorizedApplication_put_Name( app, name );
2187  SysFreeString( name );
2188  ok( hr == S_OK, "got %08x\n", hr );
2189  if (hr != S_OK) goto done;
2190 
2191  if (op == APP_ADD)
2192  hr = INetFwAuthorizedApplications_Add( apps, app );
2193  else if (op == APP_REMOVE)
2194  hr = INetFwAuthorizedApplications_Remove( apps, image );
2195  else
2196  hr = E_INVALIDARG;
2197 
2198 done:
2199  if (app) INetFwAuthorizedApplication_Release( app );
2200  if (apps) INetFwAuthorizedApplications_Release( apps );
2201  if (policy) INetFwPolicy_Release( policy );
2202  if (profile) INetFwProfile_Release( profile );
2203  if (mgr) INetFwMgr_Release( mgr );
2204  if (SUCCEEDED( init )) CoUninitialize();
2205  SysFreeString( image );
2206  return hr;
2207 }
2208 
2210 {
2211  ULONG size = 0;
2212  int argc;
2213  char **argv;
2214  BOOL firewall_enabled = is_firewall_enabled(), firewall_disabled = FALSE;
2215 
2217 
2218  ok(!GetUserNameExA(NameSamCompatible, NULL, &size), "GetUserNameExA\n");
2220  ok(GetUserNameExA(NameSamCompatible, domain_and_user, &size), "GetUserNameExA\n");
2221 
2223  progname = argv[0];
2224 
2225  if (argc == 3)
2226  {
2227  RpcTryExcept
2228  {
2229  client(argv[2]);
2230  }
2231  RpcExcept(TRUE)
2232  {
2233  trace("Exception %d\n", RpcExceptionCode());
2234  }
2235  RpcEndExcept
2236  }
2237  else if (argc == 4)
2238  {
2239  if (!strcmp(argv[3], "listen"))
2240  {
2242  }
2243  else if(!strcmp(argv[2], "run"))
2244  {
2245  UINT_PTR event;
2246  sscanf(argv[3], "%lx", &event);
2248  }
2249  }
2250  else
2251  {
2252  if (firewall_enabled)
2253  {
2254  if (is_process_elevated())
2255  {
2257  if (hr == S_OK)
2258  {
2259  firewall_enabled = FALSE;
2260  firewall_disabled = TRUE;
2261  }
2262  else
2263  {
2264  skip("can't authorize app in firewall %08x\n", hr);
2265  }
2266  }
2267  else
2268  {
2269  trace("no privileges, skipping tests to avoid firewall dialog\n");
2270  }
2271  }
2272 
2273  if (!firewall_enabled) server();
2274 
2275  /* Those tests cause occasional crashes on winxp and win2k3 */
2276  if (GetProcAddress(GetModuleHandleA("rpcrt4.dll"), "RpcExceptionFilter"))
2277  test_reconnect();
2278  else
2279  win_skip("Skipping reconnect tests on too old Windows version\n");
2280 
2281  run_client("test listen");
2282  if (firewall_disabled) set_firewall(APP_REMOVE);
2283  }
2284 
2286 }
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 * u
Definition: glfuncs.h:240
static const WCHAR helloW[]
Definition: server.c:59
int __cdecl s_sum_puints(puints_t *p)
Definition: server.c:366
RPC_STATUS RPC_ENTRY RPC_IF_CALLBACK_FN(RPC_IF_HANDLE InterfaceUuid, void *Context)
Definition: rpcdce.h:211
int __cdecl s_sum_double_int(int x, double y)
Definition: server.c:125
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:607
#define abs(i)
Definition: fconv.c:206
int __cdecl s_sum_array_ptr(int(*a)[2])
Definition: server.c:869
static BOOL is_process_elevated(void)
Definition: server.c:2088
static int argc
Definition: ServiceArgs.c:12
#define trace(...)
Definition: kmt_test.h:217
GLint level
Definition: gl.h:1546
#define RPC_C_AUTHN_WINNT
Definition: rpcdce.h:158
#define RpcEndExcept
Definition: rpc.h:128
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:784
int __cdecl s_sum_pcarr(int *a[], int n)
Definition: server.c:427
int __cdecl s_sum_padded(padded_t *p)
Definition: server.c:483
enum _TOKEN_ELEVATION_TYPE TOKEN_ELEVATION_TYPE
ULONG __RPC_USER bstr_t_UserSize(ULONG *flags, ULONG start, bstr_t *b)
Definition: server.c:1215
#define TRUE
Definition: types.h:120
const char * ws
Definition: skip_ws.cpp:7
api
Definition: notification.c:37
#define CloseHandle
Definition: compat.h:398
int __cdecl s_str_struct_len(str_struct_t *s)
Definition: server.c:512
RPC_STATUS WINAPI RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)
Definition: rpc_server.c:1599
void __cdecl s_get_a_bstr(bstr_t *b)
Definition: server.c:560
int __cdecl s_sum_cpuints(cpuints_t *p)
Definition: server.c:375
ULONG ImpersonationType
Definition: rpcdce.h:267
struct outqueuenode * tail
Definition: adnsresfilter.c:66
#define ENCU_F
#define WideCharToMultiByte
Definition: compat.h:101
HRESULT hr
Definition: shlfolder.c:183
#define __cdecl
Definition: accygwin.h:79
str_t __cdecl s_get_filename(void)
Definition: server.c:629
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
int __cdecl s_test_list_length(test_list_t *list)
Definition: server.c:234
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:342
#define test_is_server_listening(a, b)
Definition: server.c:1635
ULONG __RPC_USER puint_t_UserSize(ULONG *flags, ULONG start, puint_t *p)
Definition: server.c:1154
int __cdecl s_dot_two_vectors(vector_t vs[2])
Definition: server.c:307
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
int __cdecl s_sum_bogus(bogus_t *b)
Definition: server.c:502
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define pt(x, y)
Definition: drawing.c:79
float __cdecl s_square_half_float(float x, float *y)
Definition: server.c:184
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define CP_ACP
Definition: compat.h:99
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
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
static HANDLE stop_event
Definition: server.c:44
static void union_tests(void)
Definition: server.c:1068
void __cdecl s_get_ranged_enum(renum_t *re)
Definition: server.c:644
int __cdecl s_sum_L1_norms(int n, vector_t *vs)
Definition: server.c:611
int fnprintf(const char *format,...)
Definition: server.idl:35
static void void ULONG
Definition: server.c:46
void * RPC_AUTHZ_HANDLE
Definition: rpcdce.h:48
GLdouble n
Definition: glext.h:7729
int __cdecl s_sum_fixed_int_3d(int m[2][3][4])
Definition: server.c:241
static void run_server(HANDLE ready_event)
Definition: server.c:2002
GLdouble GLdouble t
Definition: gl.h:2047
void __cdecl s_check_null(int *null)
Definition: server.c:507
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void __cdecl s_authinfo_test(unsigned int protseq, int secure)
Definition: server.c:1537
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:679
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
GLuint buffer
Definition: glext.h:5915
int startup(int argc, const char *argv[])
Definition: startup.c:430
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
BOOLEAN WINAPI GetUserNameExA(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
Definition: sspi.c:1044
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
int __cdecl s_sum_parr(int *a[3])
Definition: server.c:422
HDC dc
Definition: cylfrac.c:34
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc)
Definition: rpc_binding.c:1569
static void NDR_RUNDOWN
Definition: server.c:46
static void server(void)
Definition: server.c:1751
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
#define test
Definition: rosglue.h:37
GLuint GLuint end
Definition: gl.h:1545
OLECHAR * BSTR
Definition: compat.h:1927
TCHAR * cmdline
Definition: stretchblt.cpp:32
static test_list_t * null_list(void)
Definition: server.c:1128
#define RPC_PROTSEQ_LRPC
Definition: rpcdce.h:127
#define RPC_C_IMP_LEVEL_IMPERSONATE
Definition: rpcdce.h:176
#define argv
Definition: mplay32.c:18
void __cdecl s_make_pyramid_doub_carr(unsigned char n, doub_carr_t **dc)
Definition: server.c:532
void __cdecl s_context_handle_test(void)
Definition: server.c:649
#define lstrlenW
Definition: compat.h:407
#define E_FAIL
Definition: ddrawi.h:102
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:161
#define RPC_IF_AUTOLISTEN
Definition: rpcdce.h:313
static test_list_t * make_list(test_list_t *tail)
Definition: server.c:1137
double __cdecl s_square_half(double x, double *y)
Definition: server.c:178
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
short VARIANT_BOOL
Definition: compat.h:1924
Definition: send.c:47
RPC_STATUS WINAPI RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, UINT WaitForCallsToComplete)
Definition: rpc_server.c:1209
static int init
Definition: wintirpc.c:33
int __cdecl s_square_puint(puint_t p)
Definition: server.c:360
INT64 hyper
Definition: rpcndr.h:117
const GLfloat * m
Definition: glext.h:10848
int __cdecl s_square(int x)
Definition: server.c:100
double __cdecl s_ptypes_sum(ptypes_t *pt)
Definition: server.c:206
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:597
ULONG Capabilities
Definition: rpcdce.h:265
#define INT_CODE
Definition: server.c:39
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
void __cdecl s_stop_autolisten(void)
Definition: server.c:847
static UUID RPC_MGR_EPV unsigned unsigned RPC_IF_CALLBACK_FN *static RPC_AUTH_IDENTITY_HANDLE
Definition: server.c:50
#define RPC_S_ACCESS_DENIED
Definition: rpcnterr.h:29
#define test_is_server_listening2(a, b, c)
Definition: server.c:1644
struct _test_info info[]
Definition: SetCursorPos.c:19
static HRESULT set_firewall(enum firewall_op op)
Definition: server.c:2143
#define sprintf(buf, format,...)
Definition: sprintf.c:55
GLuint GLuint * names
Definition: glext.h:11545
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: rpcdcep.h:104
void __cdecl s_get_names(int *n, str_array_t *names)
Definition: server.c:578
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:269
static void(WINAPI *pNDRSContextMarshall2)(RPC_BINDING_HANDLE
int __cdecl s_sum_var_array(int x[20], int n)
Definition: server.c:291
long RPC_STATUS
Definition: rpc.h:52
static HANDLE stop_wait_event
Definition: server.c:44
static void _test_is_server_listening2(unsigned line, RPC_BINDING_HANDLE binding, RPC_STATUS expected_status, RPC_STATUS expected_status2)
Definition: server.c:1645
uint32_t cs
Definition: isohybrid.c:75
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
const GUID * guid
static void client(const char *test)
Definition: server.c:1656
int __cdecl s_sum_unique_conf_ptr(int *x, int n)
Definition: server.c:286
static DWORD WINAPI listen_test_client_thread(void *binding)
Definition: server.c:1847
void * RPC_IF_HANDLE
Definition: rpcdce.h:49
int hash
Definition: main.c:58
int __cdecl s_sum(int x, int y)
Definition: server.c:105
#define PORT
Definition: server.c:36
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define a
Definition: ke_i.h:78
#define e
Definition: ke_i.h:82
int __cdecl s_sum_doub_carr(doub_carr_t *dc)
Definition: server.c:522
unsigned char *__RPC_USER us_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
Definition: server.c:1199
#define RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH
Definition: rpcdce.h:317
int __cdecl s_sum_padded_conf(padded_t *ps, int n)
Definition: server.c:493
int __cdecl s_str_t_length(str_t s)
Definition: server.c:160
#define SUN_PI
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
GLenum GLint ref
Definition: glext.h:6028
static void InitFunctionPointers(void)
Definition: server.c:62
static const WCHAR * get_filename(const WCHAR *name, const WCHAR *endptr)
Definition: module.c:68
#define RpcTryExcept
Definition: rpc.h:126
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: CString.cpp:62
int __cdecl s_enum_ord(e_t e)
Definition: server.c:435
void __cdecl s_full_pointer_null_test(int *a, int *b)
Definition: server.c:825
s123_t *__cdecl s_get_s123(void)
Definition: server.c:620
int get_name(unsigned char **pos, uint32_t *remaining, const char **out_name)
Definition: util.c:55
static void free_list(test_list_t *list)
Definition: server.c:1146
#define RPC_C_LISTEN_MAX_CALLS_DEFAULT
Definition: rpcdce.h:122
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
int __cdecl s_sum_float(float x, float y)
Definition: server.c:120
fnprintf * p_printf
Definition: server.c:57
Definition: oleaut.c:87
#define E_INVALIDARG
Definition: ddrawi.h:101
GLdouble GLdouble z
Definition: glext.h:5874
const WCHAR * str
#define MAKELONG(a, b)
Definition: typedefs.h:248
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:112
smooth NULL
Definition: ftsmooth.c:416
static char * domain_and_user
Definition: server.c:54
ULONG IdentityTracking
Definition: rpcdce.h:266
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:241
static void test_server_listening(void)
Definition: server.c:1920
#define RPC_S_CANNOT_SUPPORT
Definition: winerror.h:1072
Definition: parser.c:48
void __RPC_USER us_t_UserFree(ULONG *flags, us_t *pus)
Definition: server.c:1209
#define SUN_F2
int __cdecl s_int_return(void)
Definition: server.c:95
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
#define __RPC_FAR
Definition: rpc.h:56
int __cdecl s_sum_toplev_conf_cond(int *x, int a, int b, int c)
Definition: server.c:468
int __cdecl s_sum_complex_array(int n, refpint_t pi[])
Definition: server.c:299
#define __RPC_USER
Definition: rpc.h:65
static int sum(int x_, int y_)
Definition: ptr2_test.cpp:35
RPC_STATUS WINAPI RpcRevertToSelf(void)
Definition: rpc_binding.c:1460
#define b
Definition: ke_i.h:79
static const char * progname
Definition: server.c:41
#define PIPE
Definition: server.c:37
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE *ServerBinding)
Definition: rpc_binding.c:1643
GLuint GLfloat * val
Definition: glext.h:7180
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026
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 GLint GLint j
Definition: glfuncs.h:250
void __cdecl s_ip_test(ipu_t *a)
Definition: server.c:855
#define ok(value,...)
Definition: CComObject.cpp:34
static void test_stop_wait_for_call(unsigned char *binding)
Definition: server.c:1875
int __cdecl s_sum_cps(cps_t *cps)
Definition: server.c:324
double __cdecl s_square_sun(sun_t *su)
Definition: server.c:221
unsigned char *__RPC_USER puint_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
Definition: server.c:1168
static NDR_SCONTEXT
Definition: server.c:46
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
START_TEST(server)
Definition: server.c:2209
#define RPC_C_AUTHN_LEVEL_PKT_PRIVACY
Definition: rpcdce.h:151
GLfloat f
Definition: glext.h:7540
void __cdecl s_check_se2(se_t *s)
Definition: server.c:417
#define RpcExceptionCode()
Definition: rpc.h:132
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define WAIT_OBJECT_0
Definition: winbase.h:387
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define d
Definition: ke_i.h:81
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:837
#define TOKEN_QUERY
Definition: setypes.h:874
int __cdecl s_sum_conf_ptr_by_conf_ptr(int n1, int *n2_then_x1, int *x2)
Definition: server.c:265
int __cdecl s_sum_cs(cs_t *cs)
Definition: server.c:319
static void set_auth_info(RPC_BINDING_HANDLE handle)
Definition: server.c:1620
__wchar_t WCHAR
Definition: xmlstorage.h:180
ULONG __RPC_USER us_t_UserSize(ULONG *flags, ULONG start, us_t *pus)
Definition: server.c:1184
#define TL_LIST
double __cdecl s_square_encue(encue_t *eue)
Definition: server.c:448
LONG HRESULT
Definition: typedefs.h:77
static UUID RPC_MGR_EPV unsigned unsigned RPC_IF_CALLBACK_FN *static RPC_SECURITY_QOS *static RPC_AUTH_KEY_RETRIEVAL_FN
Definition: server.c:52
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
static DWORD WINAPI wait_listen_proc(void *arg)
Definition: server.c:1863
int __cdecl s_dot_copy_vectors(vector_t u, vector_t v)
Definition: server.c:384
RPC_STATUS WINAPI RpcServerUseProtseqEpA(RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:917
HANDLE WINAPI GetCurrentProcess(VOID)
Definition: proc.c:1168
#define RPC_S_UNKNOWN_MGR_TYPE
Definition: winerror.h:1027
unsigned char *__RPC_USER bstr_t_UserMarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
Definition: server.c:1221
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4772
void __RPC_USER bstr_t_UserFree(ULONG *flags, bstr_t *b)
Definition: server.c:1241
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
const GLubyte * c
Definition: glext.h:8905
#define for
Definition: utility.h:88
unsigned long DWORD
Definition: ntddk_ex.h:95
int __cdecl s_wstr_struct_len(wstr_struct_t *s)
Definition: server.c:517
GLuint address
Definition: glext.h:9393
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
int n1
Definition: dwarfget.c:148
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
void __RPC_FAR *__RPC_USER midl_user_allocate(size_t len)
Definition: server.c:70
int __cdecl s_echo_ranged_int(int i, int j, int k)
Definition: server.c:634
LONG __cdecl s_square_half_long(LONG x, LONG *y)
Definition: server.c:190
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
int __cdecl s_sum_ptr_array(int *a[2])
Definition: server.c:864
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int winetest_get_mainargs(char ***pargv)
GLbitfield flags
Definition: glext.h:7161
#define WAIT_TIMEOUT
Definition: dderror.h:14
short __cdecl s_sum_short(short x, short y)
Definition: server.c:115
static void array_tests(void)
Definition: server.c:1379
void __cdecl s_get_number_array(int x[20], int *n)
Definition: server.c:312
static DWORD pi
Definition: protocol.c:150
void __cdecl s_stop(void)
Definition: server.c:831
int ret
void __RPC_USER puint_t_UserFree(ULONG *flags, puint_t *p)
Definition: server.c:1178
#define SUN_I
static char * xstrdup(const char *s)
Definition: server.c:88
Definition: mxnamespace.c:44
#define SUN_F1
static const WCHAR L[]
Definition: oid.c:1250
#define RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH
Definition: rpcdce.h:185
#define todo_wine
Definition: test.h:154
unsigned __cdecl s_hash_bstr(bstr_t b)
Definition: server.c:549
static HANDLE ULONG_PTR DWORD threads
Definition: process.c:81
void __cdecl s_get_numbers(int length, int size, pints_t n[])
Definition: server.c:789
int __cdecl s_dot_self(vector_t *v)
Definition: server.c:173
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:819
GLdouble s
Definition: gl.h:2039
Definition: _list.h:228
static const WCHAR worldW[]
Definition: server.c:60
void __cdecl s_square_out(int x, int *y)
Definition: server.c:145
int __cdecl s_sum_toplev_conf_2n(int *x, int n)
Definition: server.c:459
#define RPC_C_QOS_IDENTITY_STATIC
Definition: rpcdce.h:180
struct _cl_event * event
Definition: glext.h:7739
static void run_tests(void)
Definition: server.c:1610
static void _test_is_server_listening(unsigned line, RPC_BINDING_HANDLE binding, RPC_STATUS expected_status)
Definition: server.c:1636
RPC_BINDING_HANDLE WINAPI I_RpcGetCurrentCallHandle(void)
Definition: rpc_server.c:1746
static UUID RPC_MGR_EPV unsigned unsigned RPC_IF_CALLBACK_FN *static RPC_CSTR
Definition: server.c:50
void __cdecl s_get_namesw(int *n, wstr_array_t *names)
Definition: server.c:592
#define broken(x)
Definition: _sntprintf.h:21
int __cdecl s_sum_char_hyper(signed char x, hyper y)
Definition: server.c:140
#define RPC_PROTSEQ_TCP
Definition: rpcdce.h:125
#define RPC_S_ALREADY_LISTENING
Definition: winerror.h:1024
void winetest_wait_child_process(HANDLE process)
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3234
unsigned char *__RPC_USER us_t_UserMarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
Definition: server.c:1190
int __cdecl s_dot_pvectors(pvectors_t *p)
Definition: server.c:211
#define RPC_S_BINDING_HAS_NO_AUTH
Definition: winerror.h:1054
static UUID RPC_MGR_EPV unsigned unsigned RPC_IF_CALLBACK_FN *static RPC_SECURITY_QOS *static LPVOID
Definition: server.c:52
ULONG_PTR SIZE_T
Definition: typedefs.h:78
static HANDLE create_server_process(void)
Definition: server.c:1976
#define S_OK
Definition: intsafe.h:59
#define TL_NULL
Definition: nis.h:10
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
const GLdouble * v
Definition: gl.h:2040
#define lstrcpyW
Definition: compat.h:406
void __cdecl s_square_ref(int *x)
Definition: server.c:150
static BOOL is_firewall_enabled(void)
Definition: server.c:2104
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:1991
GLuint start
Definition: gl.h:1545
#define ARRAY_SIZE(a)
Definition: main.h:24
unsigned char *__RPC_USER bstr_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
Definition: server.c:1230
#define skip(...)
Definition: CString.cpp:57
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
#define list
Definition: rosglue.h:35
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:1935
signed char __cdecl s_sum_char(signed char x, signed char y)
Definition: server.c:110
void __cdecl s_full_pointer_test(int *a, int *b)
Definition: server.c:818
#define min(a, b)
Definition: monoChain.cc:55
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:274
RPC_STATUS WINAPI RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
Definition: rpc_binding.c:1053
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:296
int __cdecl s_echo_ranged_int2(int i)
Definition: server.c:639
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
RPC_STATUS WINAPI RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding)
Definition: rpc_server.c:1707
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
int __cdecl s_get_cpsc(int n, cpsc_t *cpsc)
Definition: server.c:347
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
hyper __cdecl s_sum_hyper(hyper x, hyper y)
Definition: server.c:130
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
void __cdecl s_get_numbers_struct(numbers_struct_t **ns)
Definition: server.c:801
Definition: name.c:36
#define RPC_MGR_EPV
Definition: rpcdce.h:53
int __cdecl s_sum_conf_array(int x[], int n)
Definition: server.c:254
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define c
Definition: ke_i.h:80
static void basic_tests(void)
Definition: server.c:898
void __cdecl s_get_name(name_t *name)
Definition: server.c:569
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
int __cdecl s_sum_fixed_array(int a[5])
Definition: server.c:196
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
RPC_STATUS WINAPI RpcMgmtWaitServerListen(void)
Definition: rpc_server.c:1546
static const WCHAR sp[]
Definition: suminfo.c:288
#define GetProcAddress(x, y)
Definition: compat.h:410
#define profile
Definition: kernel32.h:12
static void make_cmdline(char buffer[MAX_PATH], const char *test)
Definition: server.c:875
int __cdecl s_sum_cpsc(cpsc_t *cpsc)
Definition: server.c:338
UINT op
Definition: effect.c:223
void *__RPC_USER MIDL_user_allocate(SIZE_T size)
Definition: irotp.c:371
static void free_pyramid_doub_carr(doub_carr_t *dc)
Definition: server.c:1370
I_RPC_HANDLE RPC_BINDING_HANDLE
Definition: rpcdce.h:50
static void test_reconnect(void)
Definition: server.c:2041
int __cdecl s_sum_sp(sp_t *sp)
Definition: server.c:216
#define ENCU_I
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
double __cdecl s_square_unencu(int t, unencu_t *eu)
Definition: server.c:406
GLfloat GLfloat p
Definition: glext.h:8902
static const WCHAR ca[]
Definition: main.c:457
double __cdecl s_square_encu(encu_t *eu)
Definition: server.c:395
#define ss
Definition: i386-dis.c:432
static BOOL old_windows_version
Definition: server.c:42
int __cdecl s_sum_unique_conf_array(int x[], int n)
Definition: server.c:281
void __RPC_USER MIDL_user_free(void *p)
Definition: irotp.c:376
int __cdecl s_sum_pcarr2(int n, int **pa)
Definition: server.c:606
Definition: _hash_fun.h:40
static void run_client(const char *test)
Definition: server.c:881
USHORT port
Definition: uri.c:227
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
int __cdecl s_cstr_length(const char *s, int n)
Definition: server.c:165
static RPC_STATUS(WINAPI *pRpcServerRegisterIfEx)(RPC_IF_HANDLE
#define win_skip
Definition: test.h:141
int k
Definition: mpi.c:3369
unsigned char *__RPC_USER puint_t_UserMarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
Definition: server.c:1160
#define HeapFree(x, y, z)
Definition: compat.h:394
double __cdecl s_sum_aligns(aligns_t *a)
Definition: server.c:478
int __cdecl s_square_test_us(test_us_t *tus)
Definition: server.c:389
static const WCHAR testW[]
Definition: jsregexp.c:44
#define RPC_PROTSEQ_NMP
Definition: rpcdce.h:126
#define RPC_S_OK
Definition: rpcnterr.h:22
#define SUCCEEDED(hr)
Definition: intsafe.h:57
int __cdecl s_pints_sum(pints_t *pints)
Definition: server.c:201
#define RpcExcept(expr)
Definition: rpc.h:127
static void pointer_tests(void)
Definition: server.c:1247
int __cdecl s_sum_hyper_int(hyper x, hyper y)
Definition: server.c:135
#define ok_(x1, x2)
Definition: CString.cpp:56
WCHAR * name
Definition: name.c:40
static int check_pyramid_doub_carr(doub_carr_t *dc)
Definition: server.c:1359
static DWORD WINAPI basic_tests_thread(void *arg)
Definition: server.c:2035
#define printf
Definition: config.h:203
void __RPC_USER midl_user_free(void __RPC_FAR *ptr)
Definition: server.c:75
int __cdecl s_sum_padded2(padded_t ps[2])
Definition: server.c:488
RPCRTAPI RPC_STATUS RPC_ENTRY RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc, ULONG *AuthzSvc, ULONG Flags)
Definition: rpc_binding.c:1593
int __cdecl s_str_length(const char *s)
Definition: server.c:155
Definition: ps.c:97
static UUID RPC_MGR_EPV unsigned int
Definition: server.c:48
GLuint const GLchar * name
Definition: glext.h:6031