dlls/rpcrt4/tests/server.c

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