git.oblomov.eu Git - wine/blob - 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 #include <windows.h>
  22 #include <secext.h>
  23 #include <rpcdce.h>
  24 #include "wine/test.h"
  25 #include "server.h"
  26 #include "server_defines.h"
  27
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #define PORT "4114"
  33 #define PIPE "\\pipe\\wine_rpcrt4_test"
  34
  35 #define INT_CODE 4198
  36
  37 static const char *progname;
  38 static BOOL old_windows_version;
  39
  40 static HANDLE stop_event;
  41
  42 static void (WINAPI *pNDRSContextMarshall2)(RPC_BINDING_HANDLE, NDR_SCONTEXT, void*, NDR_RUNDOWN, void*, ULONG);
  43 static NDR_SCONTEXT (WINAPI *pNDRSContextUnmarshall2)(RPC_BINDING_HANDLE, void*, ULONG, void*, ULONG);
  44 static RPC_STATUS (WINAPI *pRpcServerRegisterIfEx)(RPC_IF_HANDLE,UUID*, RPC_MGR_EPV*, unsigned int,
  45                    unsigned int,RPC_IF_CALLBACK_FN*);
  46 static BOOLEAN (WINAPI *pGetUserNameExA)(EXTENDED_NAME_FORMAT, LPSTR, PULONG);
  47 static RPC_STATUS (WINAPI *pRpcBindingSetAuthInfoExA)(RPC_BINDING_HANDLE, RPC_CSTR, ULONG, ULONG,
  48                                                       RPC_AUTH_IDENTITY_HANDLE, ULONG, RPC_SECURITY_QOS *);
  49 static RPC_STATUS (WINAPI *pRpcServerRegisterAuthInfoA)(RPC_CSTR, ULONG, RPC_AUTH_KEY_RETRIEVAL_FN, LPVOID);
  50
  51 static char *domain_and_user;
  52
  53 /* type check statements generated in header file */
  54 fnprintf *p_printf = printf;
  55
  56 static void InitFunctionPointers(void)
  57 {
  58     HMODULE hrpcrt4 = GetModuleHandleA("rpcrt4.dll");
  59     HMODULE hsecur32 = LoadLibraryA("secur32.dll");
  60
  61     pNDRSContextMarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextMarshall2");
  62     pNDRSContextUnmarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextUnmarshall2");
  63     pRpcServerRegisterIfEx = (void *)GetProcAddress(hrpcrt4, "RpcServerRegisterIfEx");
  64     pRpcBindingSetAuthInfoExA = (void *)GetProcAddress(hrpcrt4, "RpcBindingSetAuthInfoExA");
  65     pRpcServerRegisterAuthInfoA = (void *)GetProcAddress(hrpcrt4, "RpcServerRegisterAuthInfoA");
  66     pGetUserNameExA = (void *)GetProcAddress(hsecur32, "GetUserNameExA");
  67
  68     if (!pNDRSContextMarshall2) old_windows_version = TRUE;
  69 }
  70
  71 void __RPC_FAR *__RPC_USER
  72 midl_user_allocate(SIZE_T n)
  73 {
  74   return HeapAlloc(GetProcessHeap(), 0, n);
  75 }
  76
  77 void __RPC_USER
  78 midl_user_free(void __RPC_FAR *p)
  79 {
  80   HeapFree(GetProcessHeap(), 0, p);
  81 }
  82
  83 static char *
  84 xstrdup(const char *s)
  85 {
  86   char *d = HeapAlloc(GetProcessHeap(), 0, strlen(s) + 1);
  87   strcpy(d, s);
  88   return d;
  89 }
  90
  91 int
  92 s_int_return(void)
  93 {
  94   return INT_CODE;
  95 }
  96
  97 int
  98 s_square(int x)
  99 {
 100   return x * x;
 101 }
 102
 103 int
 104 s_sum(int x, int y)
 105 {
 106   return x + y;
 107 }
 108
 109 void
 110 s_square_out(int x, int *y)
 111 {
 112   *y = s_square(x);
 113 }
 114
 115 void
 116 s_square_ref(int *x)
 117 {
 118   *x = s_square(*x);
 119 }
 120
 121 int
 122 s_str_length(const char *s)
 123 {
 124   return strlen(s);
 125 }
 126
 127 int
 128 s_str_t_length(str_t s)
 129 {
 130   return strlen(s);
 131 }
 132
 133 int
 134 s_cstr_length(const char *s, int n)
 135 {
 136   int len = 0;
 137   while (0 < n-- && *s++)
 138     ++len;
 139   return len;
 140 }
 141
 142 int
 143 s_dot_self(vector_t *v)
 144 {
 145   return s_square(v->x) + s_square(v->y) + s_square(v->z);
 146 }
 147
 148 double
 149 s_square_half(double x, double *y)
 150 {
 151   *y = x / 2.0;
 152   return x * x;
 153 }
 154
 155 float
 156 s_square_half_float(float x, float *y)
 157 {
 158   *y = x / 2.0f;
 159   return x * x;
 160 }
 161
 162 LONG
 163 s_square_half_long(LONG x, LONG *y)
 164 {
 165   *y = x / 2;
 166   return x * x;
 167 }
 168
 169 int
 170 s_sum_fixed_array(int a[5])
 171 {
 172   return a[0] + a[1] + a[2] + a[3] + a[4];
 173 }
 174
 175 int
 176 s_pints_sum(pints_t *pints)
 177 {
 178   return *pints->pi + **pints->ppi + ***pints->pppi;
 179 }
 180
 181 double
 182 s_ptypes_sum(ptypes_t *pt)
 183 {
 184   return *pt->pc + *pt->ps + *pt->pl + *pt->pf + *pt->pd;
 185 }
 186
 187 int
 188 s_dot_pvectors(pvectors_t *p)
 189 {
 190   return p->pu->x * (*p->pv)->x + p->pu->y * (*p->pv)->y + p->pu->z * (*p->pv)->z;
 191 }
 192
 193 int
 194 s_sum_sp(sp_t *sp)
 195 {
 196   return sp->x + sp->s->x;
 197 }
 198
 199 double
 200 s_square_sun(sun_t *su)
 201 {
 202   switch (su->s)
 203   {
 204   case SUN_I: return su->u.i * su->u.i;
 205   case SUN_F1:
 206   case SUN_F2: return su->u.f * su->u.f;
 207   case SUN_PI: return (*su->u.pi) * (*su->u.pi);
 208   default:
 209     return 0.0;
 210   }
 211 }
 212
 213 int
 214 s_test_list_length(test_list_t *list)
 215 {
 216   return (list->t == TL_LIST
 217           ? 1 + s_test_list_length(list->u.tail)
 218           : 0);
 219 }
 220
 221 int
 222 s_sum_fixed_int_3d(int m[2][3][4])
 223 {
 224   int i, j, k;
 225   int sum = 0;
 226
 227   for (i = 0; i < 2; ++i)
 228     for (j = 0; j < 3; ++j)
 229       for (k = 0; k < 4; ++k)
 230         sum += m[i][j][k];
 231
 232   return sum;
 233 }
 234
 235 int
 236 s_sum_conf_array(int x[], int n)
 237 {
 238   int *p = x, *end = p + n;
 239   int sum = 0;
 240
 241   while (p < end)
 242     sum += *p++;
 243
 244   return sum;
 245 }
 246
 247 int
 248 s_sum_conf_ptr_by_conf_ptr(int n1, int *n2_then_x1, int *x2)
 249 {
 250   int i;
 251   int sum = 0;
 252   if(n1 == 0)
 253     return 0;
 254
 255   for(i = 1; i < n1; ++i)
 256     sum += n2_then_x1[i];
 257
 258   for(i = 0; i < *n2_then_x1; ++i)
 259     sum += x2[i];
 260
 261   return sum;
 262 }
 263
 264 int
 265 s_sum_unique_conf_array(int x[], int n)
 266 {
 267   return s_sum_conf_array(x, n);
 268 }
 269
 270 int
 271 s_sum_unique_conf_ptr(int *x, int n)
 272 {
 273   return x ? s_sum_conf_array(x, n) : 0;
 274 }
 275
 276 int
 277 s_sum_var_array(int x[20], int n)
 278 {
 279   ok(0 <= n, "RPC sum_var_array\n");
 280   ok(n <= 20, "RPC sum_var_array\n");
 281
 282   return s_sum_conf_array(x, n);
 283 }
 284
 285 int
 286 s_dot_two_vectors(vector_t vs[2])
 287 {
 288   return vs[0].x * vs[1].x + vs[0].y * vs[1].y + vs[0].z * vs[1].z;
 289 }
 290
 291 int
 292 s_sum_cs(cs_t *cs)
 293 {
 294   return s_sum_conf_array(cs->ca, cs->n);
 295 }
 296
 297 int
 298 s_sum_cps(cps_t *cps)
 299 {
 300   int sum = 0;
 301   int i;
 302
 303   for (i = 0; i < *cps->pn; ++i)
 304     sum += cps->ca1[i];
 305
 306   for (i = 0; i < 2 * cps->n; ++i)
 307     sum += cps->ca2[i];
 308
 309   return sum;
 310 }
 311
 312 int
 313 s_sum_cpsc(cpsc_t *cpsc)
 314 {
 315   int sum = 0;
 316   int i;
 317   for (i = 0; i < (cpsc->c ? cpsc->a : cpsc->b); ++i)
 318     sum += cpsc->ca[i];
 319   return sum;
 320 }
 321
 322 int
 323 s_square_puint(puint_t p)
 324 {
 325   int n = atoi(p);
 326   return n * n;
 327 }
 328
 329 int
 330 s_sum_puints(puints_t *p)
 331 {
 332   int sum = 0;
 333   int i;
 334   for (i = 0; i < p->n; ++i)
 335     sum += atoi(p->ps[i]);
 336   return sum;
 337 }
 338
 339 int
 340 s_sum_cpuints(cpuints_t *p)
 341 {
 342   int sum = 0;
 343   int i;
 344   for (i = 0; i < p->n; ++i)
 345     sum += atoi(p->ps[i]);
 346   return sum;
 347 }
 348
 349 int
 350 s_dot_copy_vectors(vector_t u, vector_t v)
 351 {
 352   return u.x * v.x + u.y * v.y + u.z * v.z;
 353 }
 354
 355 int
 356 s_square_test_us(test_us_t *tus)
 357 {
 358   int n = atoi(tus->us.x);
 359   return n * n;
 360 }
 361
 362 double
 363 s_square_encu(encu_t *eu)
 364 {
 365   switch (eu->t)
 366   {
 367   case ENCU_I: return eu->tagged_union.i * eu->tagged_union.i;
 368   case ENCU_F: return eu->tagged_union.f * eu->tagged_union.f;
 369   default:
 370     return 0.0;
 371   }
 372 }
 373
 374 double
 375 s_square_unencu(int t, unencu_t *eu)
 376 {
 377   switch (t)
 378   {
 379   case ENCU_I: return eu->i * eu->i;
 380   case ENCU_F: return eu->f * eu->f;
 381   default:
 382     return 0.0;
 383   }
 384 }
 385
 386 void
 387 s_check_se2(se_t *s)
 388 {
 389   ok(s->f == E2, "check_se2\n");
 390 }
 391
 392 int
 393 s_sum_parr(int *a[3])
 394 {
 395   return s_sum_pcarr(a, 3);
 396 }
 397
 398 int
 399 s_sum_pcarr(int *a[], int n)
 400 {
 401   int i, s = 0;
 402   for (i = 0; i < n; ++i)
 403     s += *a[i];
 404   return s;
 405 }
 406
 407 int
 408 s_enum_ord(e_t e)
 409 {
 410   switch (e)
 411   {
 412   case E1: return 1;
 413   case E2: return 2;
 414   case E3: return 3;
 415   case E4: return 4;
 416   default:
 417     return 0;
 418   }
 419 }
 420
 421 double
 422 s_square_encue(encue_t *eue)
 423 {
 424   switch (eue->t)
 425   {
 426   case E1: return eue->tagged_union.i1 * eue->tagged_union.i1;
 427   case E2: return eue->tagged_union.f2 * eue->tagged_union.f2;
 428   default:
 429     return 0.0;
 430   }
 431 }
 432
 433 int
 434 s_sum_toplev_conf_2n(int *x, int n)
 435 {
 436   int sum = 0;
 437   int i;
 438   for (i = 0; i < 2 * n; ++i)
 439     sum += x[i];
 440   return sum;
 441 }
 442
 443 int
 444 s_sum_toplev_conf_cond(int *x, int a, int b, int c)
 445 {
 446   int sum = 0;
 447   int n = c ? a : b;
 448   int i;
 449   for (i = 0; i < n; ++i)
 450     sum += x[i];
 451   return sum;
 452 }
 453
 454 double
 455 s_sum_aligns(aligns_t *a)
 456 {
 457   return a->c + a->i + a->s + a->d;
 458 }
 459
 460 int
 461 s_sum_padded(padded_t *p)
 462 {
 463   return p->i + p->c;
 464 }
 465
 466 int
 467 s_sum_padded2(padded_t ps[2])
 468 {
 469   return s_sum_padded(&ps[0]) + s_sum_padded(&ps[1]);
 470 }
 471
 472 int
 473 s_sum_padded_conf(padded_t *ps, int n)
 474 {
 475   int sum = 0;
 476   int i;
 477   for (i = 0; i < n; ++i)
 478     sum += s_sum_padded(&ps[i]);
 479   return sum;
 480 }
 481
 482 int
 483 s_sum_bogus(bogus_t *b)
 484 {
 485   return *b->h.p1 + *b->p2 + *b->p3 + b->c;
 486 }
 487
 488 void
 489 s_check_null(int *null)
 490 {
 491   ok(!null, "RPC check_null\n");
 492 }
 493
 494 int
 495 s_str_struct_len(str_struct_t *s)
 496 {
 497   return lstrlenA(s->s);
 498 }
 499
 500 int
 501 s_wstr_struct_len(wstr_struct_t *s)
 502 {
 503   return lstrlenW(s->s);
 504 }
 505
 506 int
 507 s_sum_doub_carr(doub_carr_t *dc)
 508 {
 509   int i, j;
 510   int sum = 0;
 511   for (i = 0; i < dc->n; ++i)
 512     for (j = 0; j < dc->a[i]->n; ++j)
 513       sum += dc->a[i]->a[j];
 514   return sum;
 515 }
 516
 517 void
 518 s_make_pyramid_doub_carr(unsigned char n, doub_carr_t **dc)
 519 {
 520   doub_carr_t *t;
 521   int i, j;
 522   t = MIDL_user_allocate(FIELD_OFFSET(doub_carr_t, a[n]));
 523   t->n = n;
 524   for (i = 0; i < n; ++i)
 525   {
 526     int v = i + 1;
 527     t->a[i] = MIDL_user_allocate(FIELD_OFFSET(doub_carr_1_t, a[v]));
 528     t->a[i]->n = v;
 529     for (j = 0; j < v; ++j)
 530       t->a[i]->a[j] = j + 1;
 531   }
 532   *dc = t;
 533 }
 534
 535 unsigned
 536 s_hash_bstr(bstr_t b)
 537 {
 538   short n = b[-1];
 539   short *s = b;
 540   unsigned hash = 0;
 541   short i;
 542   for (i = 0; i < n; ++i)
 543     hash = 5 * hash + (unsigned) s[i];
 544   return hash;
 545 }
 546
 547 void
 548 s_get_name(name_t *name)
 549 {
 550   const char bossman[] = "Jeremy White";
 551   memcpy(name->name, bossman, min(name->size, sizeof(bossman)));
 552   /* ensure nul-termination */
 553   if (name->size < sizeof(bossman))
 554     name->name[name->size - 1] = 0;
 555 }
 556
 557 int
 558 s_sum_pcarr2(int n, int **pa)
 559 {
 560   return s_sum_conf_array(*pa, n);
 561 }
 562
 563 int
 564 s_sum_L1_norms(int n, vector_t *vs)
 565 {
 566   int i;
 567   int sum = 0;
 568   for (i = 0; i < n; ++i)
 569     sum += abs(vs[i].x) + abs(vs[i].y) + abs(vs[i].z);
 570   return sum;
 571 }
 572
 573 s123_t *
 574 s_get_s123(void)
 575 {
 576   s123_t *s = MIDL_user_allocate(sizeof *s);
 577   s->f1 = 1;
 578   s->f2 = 2;
 579   s->f3 = 3;
 580   return s;
 581 }
 582
 583 str_t
 584 s_get_filename(void)
 585 {
 586     return (char *)__FILE__;
 587 }
 588
 589 int s_echo_ranged_int(int n)
 590 {
 591     return n;
 592 }
 593
 594 void s_get_ranged_enum(renum_t *re)
 595 {
 596     *re = RE3;
 597 }
 598
 599 void
 600 s_context_handle_test(void)
 601 {
 602     NDR_SCONTEXT h;
 603     RPC_BINDING_HANDLE binding;
 604     RPC_STATUS status;
 605     unsigned char buf[20];
 606     static RPC_SERVER_INTERFACE server_if =
 607     {
 608         sizeof(RPC_SERVER_INTERFACE),
 609         {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
 610         {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
 611         NULL,
 612         0,
 613         0,
 614         0,
 615         0,
 616         0,
 617     };
 618
 619     binding = I_RpcGetCurrentCallHandle();
 620     ok(binding != NULL, "I_RpcGetCurrentCallHandle returned NULL\n");
 621
 622     if (!pNDRSContextMarshall2 || !pNDRSContextUnmarshall2)
 623     {
 624         win_skip("NDRSContextMarshall2 or NDRSContextUnmarshall2 not exported from rpcrt4.dll\n");
 625         return;
 626     }
 627
 628     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 629     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 630
 631     /* marshal a context handle with NULL userContext */
 632     memset(buf, 0xcc, sizeof(buf));
 633     pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
 634     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 635     ok(UuidIsNil((UUID *)&buf[4], &status), "uuid should have been nil\n");
 636
 637     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 638     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 639
 640     /* marshal a context handle with non-NULL userContext */
 641     memset(buf, 0xcc, sizeof(buf));
 642     h->userContext = (void *)0xdeadbeef;
 643     pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
 644     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 645     ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
 646
 647     /* raises ERROR_INVALID_HANDLE exception on Vista upwards */
 648     if (0)
 649     {
 650     h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 651     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 652     ok(h->userContext == (void *)0xdeadbeef, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
 653
 654     /* marshal a context handle with an interface specified */
 655     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
 656     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 657
 658     memset(buf, 0xcc, sizeof(buf));
 659     h->userContext = (void *)0xcafebabe;
 660     pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
 661     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 662     ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
 663
 664     h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
 665     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 666     ok(h->userContext == (void *)0xcafebabe, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
 667     }
 668
 669     /* test same interface data, but different pointer */
 670     /* raises ERROR_INVALID_HANDLE exception */
 671     if (0)
 672     {
 673         RPC_SERVER_INTERFACE server_if_clone = server_if;
 674
 675         pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if_clone.InterfaceId, 0);
 676     }
 677
 678     /* test different interface data, but different pointer */
 679     /* raises ERROR_INVALID_HANDLE exception */
 680     if (0)
 681     {
 682         static RPC_SERVER_INTERFACE server_if2 =
 683         {
 684             sizeof(RPC_SERVER_INTERFACE),
 685             {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
 686             {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
 687             NULL,
 688             0,
 689             0,
 690             0,
 691             0,
 692             0,
 693         };
 694         pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
 695
 696         pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if2.InterfaceId, 0);
 697     }
 698 }
 699
 700 void
 701 s_get_numbers(int length, int size, pints_t n[])
 702 {
 703     int i;
 704     for (i = 0; i < length; i++)
 705     {
 706         n[i].pi = midl_user_allocate(sizeof(*n[i].pi));
 707         *n[i].pi = i;
 708         n[i].ppi = NULL;
 709         n[i].pppi = NULL;
 710     }
 711 }
 712
 713 void
 714 s_get_numbers_struct(numbers_struct_t **ns)
 715 {
 716     int i;
 717     *ns = midl_user_allocate(FIELD_OFFSET(numbers_struct_t, numbers[5]));
 718     if (!*ns) return;
 719     (*ns)->length = 5;
 720     (*ns)->size = 5;
 721     for (i = 0; i < (*ns)->length; i++)
 722     {
 723         (*ns)->numbers[i].pi = NULL;
 724         (*ns)->numbers[i].ppi = NULL;
 725         (*ns)->numbers[i].pppi = NULL;
 726     }
 727     (*ns)->numbers[0].pi = midl_user_allocate(sizeof(*(*ns)->numbers[i].pi));
 728     *(*ns)->numbers[0].pi = 5;
 729 }
 730
 731 void
 732 s_full_pointer_test(int *a, int *b)
 733 {
 734     ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
 735     ok(*b == 42, "Expected *b to be 42 instead of %d\n", *a);
 736     ok(a == b, "Expected a (%p) to point to the same memory as b (%p)\n", a, b);
 737 }
 738
 739 void
 740 s_full_pointer_null_test(int *a, int *b)
 741 {
 742     ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
 743     ok(b == NULL, "Expected b to be NULL instead of %p\n", b);
 744 }
 745
 746 void
 747 s_stop(void)
 748 {
 749   ok(RPC_S_OK == RpcMgmtStopServerListening(NULL), "RpcMgmtStopServerListening\n");
 750   ok(RPC_S_OK == RpcServerUnregisterIf(NULL, NULL, FALSE), "RpcServerUnregisterIf\n");
 751   ok(SetEvent(stop_event), "SetEvent\n");
 752 }
 753
 754 static void
 755 make_cmdline(char buffer[MAX_PATH], const char *test)
 756 {
 757   sprintf(buffer, "%s server %s", progname, test);
 758 }
 759
 760 static void
 761 run_client(const char *test)
 762 {
 763   char cmdline[MAX_PATH];
 764   PROCESS_INFORMATION info;
 765   STARTUPINFOA startup;
 766
 767   memset(&startup, 0, sizeof startup);
 768   startup.cb = sizeof startup;
 769
 770   make_cmdline(cmdline, test);
 771   ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 772   winetest_wait_child_process( info.hProcess );
 773   ok(CloseHandle(info.hProcess), "CloseHandle\n");
 774   ok(CloseHandle(info.hThread), "CloseHandle\n");
 775 }
 776
 777 static void
 778 basic_tests(void)
 779 {
 780   char string[] = "I am a string";
 781   WCHAR wstring[] = {'I',' ','a','m',' ','a',' ','w','s','t','r','i','n','g', 0};
 782   int f[5] = {1, 3, 0, -2, -4};
 783   vector_t a = {1, 3, 7};
 784   vector_t vec1 = {4, -2, 1}, vec2 = {-5, 2, 3}, *pvec2 = &vec2;
 785   pvectors_t pvecs = {&vec1, &pvec2};
 786   sp_inner_t spi = {42};
 787   sp_t sp = {-13, &spi};
 788   aligns_t aligns;
 789   pints_t pints;
 790   ptypes_t ptypes;
 791   padded_t padded;
 792   padded_t padded2[2];
 793   bogus_t bogus;
 794   int i1, i2, i3, *pi2, *pi3, **ppi3;
 795   double u, v;
 796   float s, t;
 797   LONG q, r;
 798   short h;
 799   char c;
 800   int x;
 801   str_struct_t ss = {string};
 802   wstr_struct_t ws = {wstring};
 803   str_t str;
 804   se_t se;
 805   renum_t re;
 806
 807   ok(int_return() == INT_CODE, "RPC int_return\n");
 808
 809   ok(square(7) == 49, "RPC square\n");
 810   ok(sum(23, -4) == 19, "RPC sum\n");
 811
 812   x = 0;
 813   square_out(11, &x);
 814   ok(x == 121, "RPC square_out\n");
 815
 816   x = 5;
 817   square_ref(&x);
 818   ok(x == 25, "RPC square_ref\n");
 819
 820   ok(str_length(string) == strlen(string), "RPC str_length\n");
 821   ok(str_t_length(string) == strlen(string), "RPC str_length\n");
 822   ok(dot_self(&a) == 59, "RPC dot_self\n");
 823
 824   ok(str_struct_len(&ss) == lstrlenA(string), "RPC str_struct_len\n");
 825   ok(wstr_struct_len(&ws) == lstrlenW(wstring), "RPC str_struct_len\n");
 826
 827   v = 0.0;
 828   u = square_half(3.0, &v);
 829   ok(u == 9.0, "RPC square_half\n");
 830   ok(v == 1.5, "RPC square_half\n");
 831
 832   t = 0.0f;
 833   s = square_half_float(3.0f, &t);
 834   ok(s == 9.0f, "RPC square_half_float\n");
 835   ok(t == 1.5f, "RPC square_half_float\n");
 836
 837   r = 0;
 838   q = square_half_long(3, &r);
 839   ok(q == 9, "RPC square_half_long\n");
 840   ok(r == 1, "RPC square_half_long\n");
 841
 842   i1 = 19;
 843   i2 = -3;
 844   i3 = -29;
 845   pi2 = &i2;
 846   pi3 = &i3;
 847   ppi3 = &pi3;
 848   pints.pi = &i1;
 849   pints.ppi = &pi2;
 850   pints.pppi = &ppi3;
 851   ok(pints_sum(&pints) == -13, "RPC pints_sum\n");
 852
 853   c = 10;
 854   h = 3;
 855   q = 14;
 856   s = -5.0f;
 857   u = 11.0;
 858   ptypes.pc = &c;
 859   ptypes.ps = &h;
 860   ptypes.pl = &q;
 861   ptypes.pf = &s;
 862   ptypes.pd = &u;
 863   ok(ptypes_sum(&ptypes) == 33.0, "RPC ptypes_sum\n");
 864
 865   ok(dot_pvectors(&pvecs) == -21, "RPC dot_pvectors\n");
 866   ok(dot_copy_vectors(vec1, vec2) == -21, "RPC dot_copy_vectors\n");
 867   ok(sum_fixed_array(f) == -2, "RPC sum_fixed_array\n");
 868   ok(sum_sp(&sp) == 29, "RPC sum_sp\n");
 869
 870   ok(enum_ord(E1) == 1, "RPC enum_ord\n");
 871   ok(enum_ord(E2) == 2, "RPC enum_ord\n");
 872   ok(enum_ord(E3) == 3, "RPC enum_ord\n");
 873   ok(enum_ord(E4) == 4, "RPC enum_ord\n");
 874
 875   se.f = E2;
 876   check_se2(&se);
 877
 878   memset(&aligns, 0, sizeof(aligns));
 879   aligns.c = 3;
 880   aligns.i = 4;
 881   aligns.s = 5;
 882   aligns.d = 6.0;
 883   ok(sum_aligns(&aligns) == 18.0, "RPC sum_aligns\n");
 884
 885   padded.i = -3;
 886   padded.c = 8;
 887   ok(sum_padded(&padded) == 5, "RPC sum_padded\n");
 888   padded2[0].i = -5;
 889   padded2[0].c = 1;
 890   padded2[1].i = 3;
 891   padded2[1].c = 7;
 892   ok(sum_padded2(padded2) == 6, "RPC sum_padded2\n");
 893   padded2[0].i = -5;
 894   padded2[0].c = 1;
 895   padded2[1].i = 3;
 896   padded2[1].c = 7;
 897   ok(sum_padded_conf(padded2, 2) == 6, "RPC sum_padded_conf\n");
 898
 899   i1 = 14;
 900   i2 = -7;
 901   i3 = -4;
 902   bogus.h.p1 = &i1;
 903   bogus.p2 = &i2;
 904   bogus.p3 = &i3;
 905   bogus.c = 9;
 906   ok(sum_bogus(&bogus) == 12, "RPC sum_bogus\n");
 907
 908   check_null(NULL);
 909
 910   str = get_filename();
 911   ok(!strcmp(str, __FILE__), "get_filename() returned %s instead of %s\n", str, __FILE__);
 912   midl_user_free(str);
 913
 914   x = echo_ranged_int(0);
 915   ok(x == 0, "echo_ranged_int() returned %d instead of 0\n", x);
 916   x = echo_ranged_int(100);
 917   ok(x == 100, "echo_ranged_int() returned %d instead of 100\n", x);
 918
 919   if (!old_windows_version)
 920   {
 921       get_ranged_enum(&re);
 922       ok(re == RE3, "get_ranged_enum() returned %d instead of RE3\n", re);
 923   }
 924 }
 925
 926 static void
 927 union_tests(void)
 928 {
 929   encue_t eue;
 930   encu_t eu;
 931   unencu_t uneu;
 932   sun_t su;
 933   int i;
 934
 935   su.s = SUN_I;
 936   su.u.i = 9;
 937   ok(square_sun(&su) == 81.0, "RPC square_sun\n");
 938
 939   su.s = SUN_F1;
 940   su.u.f = 5.0;
 941   ok(square_sun(&su) == 25.0, "RPC square_sun\n");
 942
 943   su.s = SUN_F2;
 944   su.u.f = -2.0;
 945   ok(square_sun(&su) == 4.0, "RPC square_sun\n");
 946
 947   su.s = SUN_PI;
 948   su.u.pi = &i;
 949   i = 11;
 950   ok(square_sun(&su) == 121.0, "RPC square_sun\n");
 951
 952   eu.t = ENCU_I;
 953   eu.tagged_union.i = 7;
 954   ok(square_encu(&eu) == 49.0, "RPC square_encu\n");
 955
 956   eu.t = ENCU_F;
 957   eu.tagged_union.f = 3.0;
 958   ok(square_encu(&eu) == 9.0, "RPC square_encu\n");
 959
 960   uneu.i = 4;
 961   ok(square_unencu(ENCU_I, &uneu) == 16.0, "RPC square_unencu\n");
 962
 963   uneu.f = 5.0;
 964   ok(square_unencu(ENCU_F, &uneu) == 25.0, "RPC square_unencu\n");
 965
 966   eue.t = E1;
 967   eue.tagged_union.i1 = 8;
 968   ok(square_encue(&eue) == 64.0, "RPC square_encue\n");
 969
 970   eue.t = E2;
 971   eue.tagged_union.f2 = 10.0;
 972   ok(square_encue(&eue) == 100.0, "RPC square_encue\n");
 973 }
 974
 975 static test_list_t *
 976 null_list(void)
 977 {
 978   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 979   n->t = TL_NULL;
 980   n->u.x = 0;
 981   return n;
 982 }
 983
 984 static test_list_t *
 985 make_list(test_list_t *tail)
 986 {
 987   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 988   n->t = TL_LIST;
 989   n->u.tail = tail;
 990   return n;
 991 }
 992
 993 static void
 994 free_list(test_list_t *list)
 995 {
 996   if (list->t == TL_LIST)
 997     free_list(list->u.tail);
 998   HeapFree(GetProcessHeap(), 0, list);
 999 }
1000
1001 ULONG __RPC_USER
1002 puint_t_UserSize(ULONG *flags, ULONG start, puint_t *p)
1003 {
1004   return start + sizeof(int);
1005 }
1006
1007 unsigned char * __RPC_USER
1008 puint_t_UserMarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
1009 {
1010   int n = atoi(*p);
1011   memcpy(buffer, &n, sizeof n);
1012   return buffer + sizeof n;
1013 }
1014
1015 unsigned char * __RPC_USER
1016 puint_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
1017 {
1018   int n;
1019   memcpy(&n, buffer, sizeof n);
1020   *p = HeapAlloc(GetProcessHeap(), 0, 10);
1021   sprintf(*p, "%d", n);
1022   return buffer + sizeof n;
1023 }
1024
1025 void __RPC_USER
1026 puint_t_UserFree(ULONG *flags, puint_t *p)
1027 {
1028   HeapFree(GetProcessHeap(), 0, *p);
1029 }
1030
1031 ULONG __RPC_USER
1032 us_t_UserSize(ULONG *flags, ULONG start, us_t *pus)
1033 {
1034   return start + sizeof(struct wire_us);
1035 }
1036
1037 unsigned char * __RPC_USER
1038 us_t_UserMarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1039 {
1040   struct wire_us wus;
1041   wus.x = atoi(pus->x);
1042   memcpy(buffer, &wus, sizeof wus);
1043   return buffer + sizeof wus;
1044 }
1045
1046 unsigned char * __RPC_USER
1047 us_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1048 {
1049   struct wire_us wus;
1050   memcpy(&wus, buffer, sizeof wus);
1051   pus->x = HeapAlloc(GetProcessHeap(), 0, 10);
1052   sprintf(pus->x, "%d", wus.x);
1053   return buffer + sizeof wus;
1054 }
1055
1056 void __RPC_USER
1057 us_t_UserFree(ULONG *flags, us_t *pus)
1058 {
1059   HeapFree(GetProcessHeap(), 0, pus->x);
1060 }
1061
1062 ULONG __RPC_USER
1063 bstr_t_UserSize(ULONG *flags, ULONG start, bstr_t *b)
1064 {
1065   return start + FIELD_OFFSET(user_bstr_t, data[(*b)[-1]]);
1066 }
1067
1068 unsigned char * __RPC_USER
1069 bstr_t_UserMarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
1070 {
1071   wire_bstr_t wb = (wire_bstr_t) buffer;
1072   wb->n = (*b)[-1];
1073   memcpy(&wb->data, *b, wb->n * sizeof wb->data[0]);
1074   return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1075 }
1076
1077 unsigned char * __RPC_USER
1078 bstr_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
1079 {
1080   wire_bstr_t wb = (wire_bstr_t) buffer;
1081   short *data = HeapAlloc(GetProcessHeap(), 0, (wb->n + 1) * sizeof *data);
1082   data[0] = wb->n;
1083   memcpy(&data[1], wb->data, wb->n * sizeof data[1]);
1084   *b = &data[1];
1085   return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1086 }
1087
1088 void __RPC_USER
1089 bstr_t_UserFree(ULONG *flags, bstr_t *b)
1090 {
1091   HeapFree(GetProcessHeap(), 0, &((*b)[-1]));
1092 }
1093
1094 static void
1095 pointer_tests(void)
1096 {
1097   int a[] = {1, 2, 3, 4};
1098   char p1[] = "11";
1099   test_list_t *list = make_list(make_list(make_list(null_list())));
1100   test_us_t tus = {{p1}};
1101   int *pa[4];
1102   puints_t pus;
1103   cpuints_t cpus;
1104   short bstr_data[] = { 5, 'H', 'e', 'l', 'l', 'o' };
1105   bstr_t bstr = &bstr_data[1];
1106   name_t name;
1107   void *buffer;
1108   int *pa2;
1109   s123_t *s123;
1110   int val = 42;
1111
1112   ok(test_list_length(list) == 3, "RPC test_list_length\n");
1113   ok(square_puint(p1) == 121, "RPC square_puint\n");
1114   pus.n = 4;
1115   pus.ps = HeapAlloc(GetProcessHeap(), 0, pus.n * sizeof pus.ps[0]);
1116   pus.ps[0] = xstrdup("5");
1117   pus.ps[1] = xstrdup("6");
1118   pus.ps[2] = xstrdup("7");
1119   pus.ps[3] = xstrdup("8");
1120   ok(sum_puints(&pus) == 26, "RPC sum_puints\n");
1121   HeapFree(GetProcessHeap(), 0, pus.ps[0]);
1122   HeapFree(GetProcessHeap(), 0, pus.ps[1]);
1123   HeapFree(GetProcessHeap(), 0, pus.ps[2]);
1124   HeapFree(GetProcessHeap(), 0, pus.ps[3]);
1125   HeapFree(GetProcessHeap(), 0, pus.ps);
1126   cpus.n = 4;
1127   cpus.ps = HeapAlloc(GetProcessHeap(), 0, cpus.n * sizeof cpus.ps[0]);
1128   cpus.ps[0] = xstrdup("5");
1129   cpus.ps[1] = xstrdup("6");
1130   cpus.ps[2] = xstrdup("7");
1131   cpus.ps[3] = xstrdup("8");
1132   ok(sum_cpuints(&cpus) == 26, "RPC sum_puints\n");
1133   HeapFree(GetProcessHeap(), 0, cpus.ps[0]);
1134   HeapFree(GetProcessHeap(), 0, cpus.ps[1]);
1135   HeapFree(GetProcessHeap(), 0, cpus.ps[2]);
1136   HeapFree(GetProcessHeap(), 0, cpus.ps[3]);
1137   HeapFree(GetProcessHeap(), 0, cpus.ps);
1138   ok(square_test_us(&tus) == 121, "RPC square_test_us\n");
1139
1140   pa[0] = &a[0];
1141   pa[1] = &a[1];
1142   pa[2] = &a[2];
1143   ok(sum_parr(pa) == 6, "RPC sum_parr\n");
1144
1145   pa[0] = &a[0];
1146   pa[1] = &a[1];
1147   pa[2] = &a[2];
1148   pa[3] = &a[3];
1149   ok(sum_pcarr(pa, 4) == 10, "RPC sum_pcarr\n");
1150
1151   ok(hash_bstr(bstr) == s_hash_bstr(bstr), "RPC hash_bstr_data\n");
1152
1153   free_list(list);
1154
1155   if (!old_windows_version)
1156   {
1157       name.size = 10;
1158       name.name = buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, name.size);
1159       get_name(&name);
1160       ok(name.name == buffer, "[in,out] pointer should have stayed as %p but instead changed to %p\n", name.name, buffer);
1161       ok(!strcmp(name.name, "Jeremy Wh"), "name didn't unmarshall properly, expected \"Jeremy Wh\", but got \"%s\"\n", name.name);
1162       HeapFree(GetProcessHeap(), 0, name.name);
1163   }
1164
1165   pa2 = a;
1166   ok(sum_pcarr2(4, &pa2) == 10, "RPC sum_pcarr2\n");
1167
1168   s123 = get_s123();
1169   ok(s123->f1 == 1 && s123->f2 == 2 && s123->f3 == 3, "RPC get_s123\n");
1170   MIDL_user_free(s123);
1171
1172   full_pointer_test(&val, &val);
1173   full_pointer_null_test(&val, NULL);
1174 }
1175
1176 static int
1177 check_pyramid_doub_carr(doub_carr_t *dc)
1178 {
1179   int i, j;
1180   for (i = 0; i < dc->n; ++i)
1181     for (j = 0; j < dc->a[i]->n; ++j)
1182       if (dc->a[i]->a[j] != j + 1)
1183         return FALSE;
1184   return TRUE;
1185 }
1186
1187 static void
1188 free_pyramid_doub_carr(doub_carr_t *dc)
1189 {
1190   int i;
1191   for (i = 0; i < dc->n; ++i)
1192     MIDL_user_free(dc->a[i]);
1193   MIDL_user_free(dc);
1194 }
1195
1196 static void
1197 array_tests(void)
1198 {
1199   int m[2][3][4] =
1200   {
1201     {{1, 2, 3, 4}, {-1, -3, -5, -7}, {0, 2, 4, 6}},
1202     {{1, -2, 3, -4}, {2, 3, 5, 7}, {-4, -1, -14, 4114}}
1203   };
1204   int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1205   int c2[] = {10, 100, 200};
1206   vector_t vs[2] = {{1, -2, 3}, {4, -5, -6}};
1207   cps_t cps;
1208   cpsc_t cpsc;
1209   cs_t *cs;
1210   int n;
1211   int ca[5] = {1, -2, 3, -4, 5};
1212   doub_carr_t *dc;
1213   int *pi;
1214   pints_t api[5];
1215   numbers_struct_t *ns;
1216
1217   if (!old_windows_version)
1218   {
1219       const char str1[25] = "Hello";
1220       ok(cstr_length(str1, sizeof str1) == strlen(str1), "RPC cstr_length\n");
1221   }
1222
1223   ok(sum_fixed_int_3d(m) == 4116, "RPC sum_fixed_int_3d\n");
1224
1225   ok(sum_conf_array(c, 10) == 45, "RPC sum_conf_array\n");
1226   ok(sum_conf_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1227   ok(sum_conf_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1228   ok(sum_conf_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1229
1230   ok(sum_conf_ptr_by_conf_ptr(1, c2, c) == 45, "RPC sum_conf_ptr_by_conf_ptr\n");
1231   ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 345, "RPC sum_conf_ptr_by_conf_ptr\n");
1232   c2[0] = 0;
1233   ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 300, "RPC sum_conf_ptr_by_conf_ptr\n");
1234
1235   ok(sum_unique_conf_array(ca, 4) == -2, "RPC sum_unique_conf_array\n");
1236   ok(sum_unique_conf_ptr(ca, 5) == 3, "RPC sum_unique_conf_array\n");
1237   ok(sum_unique_conf_ptr(NULL, 10) == 0, "RPC sum_unique_conf_array\n");
1238
1239   ok(sum_var_array(c, 10) == 45, "RPC sum_conf_array\n");
1240   ok(sum_var_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1241   ok(sum_var_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1242   ok(sum_var_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1243
1244   ok(dot_two_vectors(vs) == -4, "RPC dot_two_vectors\n");
1245   cs = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(cs_t, ca[5]));
1246   cs->n = 5;
1247   cs->ca[0] = 3;
1248   cs->ca[1] = 5;
1249   cs->ca[2] = -2;
1250   cs->ca[3] = -1;
1251   cs->ca[4] = -4;
1252   ok(sum_cs(cs) == 1, "RPC sum_cs\n");
1253   HeapFree(GetProcessHeap(), 0, cs);
1254
1255   n = 5;
1256   cps.pn = &n;
1257   cps.ca1 = &c[2];
1258   cps.n = 3;
1259   cps.ca2 = &c[3];
1260   ok(sum_cps(&cps) == 53, "RPC sum_cps\n");
1261
1262   cpsc.a = 4;
1263   cpsc.b = 5;
1264   cpsc.c = 1;
1265   cpsc.ca = c;
1266   ok(sum_cpsc(&cpsc) == 6, "RPC sum_cpsc\n");
1267   cpsc.a = 4;
1268   cpsc.b = 5;
1269   cpsc.c = 0;
1270   cpsc.ca = c;
1271   ok(sum_cpsc(&cpsc) == 10, "RPC sum_cpsc\n");
1272
1273   ok(sum_toplev_conf_2n(c, 3) == 15, "RPC sum_toplev_conf_2n\n");
1274   ok(sum_toplev_conf_cond(c, 5, 6, 1) == 10, "RPC sum_toplev_conf_cond\n");
1275   ok(sum_toplev_conf_cond(c, 5, 6, 0) == 15, "RPC sum_toplev_conf_cond\n");
1276
1277   dc = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_t, a[2]));
1278   dc->n = 2;
1279   dc->a[0] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[3]));
1280   dc->a[0]->n = 3;
1281   dc->a[0]->a[0] = 5;
1282   dc->a[0]->a[1] = 1;
1283   dc->a[0]->a[2] = 8;
1284   dc->a[1] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[2]));
1285   dc->a[1]->n = 2;
1286   dc->a[1]->a[0] = 2;
1287   dc->a[1]->a[1] = 3;
1288   ok(sum_doub_carr(dc) == 19, "RPC sum_doub_carr\n");
1289   HeapFree(GetProcessHeap(), 0, dc->a[0]);
1290   HeapFree(GetProcessHeap(), 0, dc->a[1]);
1291   HeapFree(GetProcessHeap(), 0, dc);
1292
1293   dc = NULL;
1294   make_pyramid_doub_carr(4, &dc);
1295   ok(check_pyramid_doub_carr(dc), "RPC make_pyramid_doub_carr\n");
1296   free_pyramid_doub_carr(dc);
1297
1298   ok(sum_L1_norms(2, vs) == 21, "RPC sum_L1_norms\n");
1299
1300   memset(api, 0, sizeof(api));
1301   pi = HeapAlloc(GetProcessHeap(), 0, sizeof(*pi));
1302   *pi = -1;
1303   api[0].pi = pi;
1304   get_numbers(1, 1, api);
1305   ok(api[0].pi == pi, "RPC conformant varying array [out] pointer changed from %p to %p\n", pi, api[0].pi);
1306   ok(*api[0].pi == 0, "pi unmarshalled incorrectly %d\n", *api[0].pi);
1307
1308   if (!old_windows_version)
1309   {
1310       ns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(numbers_struct_t, numbers[5]));
1311       ns->length = 5;
1312       ns->size = 5;
1313       ns->numbers[0].pi = pi;
1314       get_numbers_struct(&ns);
1315       ok(ns->numbers[0].pi == pi, "RPC conformant varying struct embedded pointer changed from %p to %p\n", pi, ns->numbers[0].pi);
1316       ok(*ns->numbers[0].pi == 5, "pi unmarshalled incorrectly %d\n", *ns->numbers[0].pi);
1317       HeapFree(GetProcessHeap(), 0, ns);
1318   }
1319   HeapFree(GetProcessHeap(), 0, pi);
1320 }
1321
1322 void
1323 s_authinfo_test(unsigned int protseq, int secure)
1324 {
1325     RPC_BINDING_HANDLE binding;
1326     RPC_STATUS status;
1327     ULONG level, authnsvc;
1328     RPC_AUTHZ_HANDLE privs;
1329     unsigned char *principal;
1330
1331     binding = I_RpcGetCurrentCallHandle();
1332     ok(binding != NULL, "I_RpcGetCurrentCallHandle returned NULL\n");
1333
1334     level = authnsvc = 0xdeadbeef;
1335     privs = (RPC_AUTHZ_HANDLE)0xdeadbeef;
1336     principal = (unsigned char *)0xdeadbeef;
1337
1338     if (secure || protseq == RPC_PROTSEQ_LRPC)
1339     {
1340         status = RpcBindingInqAuthClientA(binding, &privs, &principal, &level, &authnsvc, NULL);
1341         ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1342         ok(privs != (RPC_AUTHZ_HANDLE)0xdeadbeef, "privs unchanged\n");
1343         ok(principal != (unsigned char *)0xdeadbeef, "principal unchanged\n");
1344         if (protseq != RPC_PROTSEQ_LRPC)
1345         {
1346             todo_wine
1347             ok(principal != NULL, "NULL principal\n");
1348         }
1349         if (protseq == RPC_PROTSEQ_LRPC && principal && pGetUserNameExA)
1350         {
1351             int len;
1352             char *spn;
1353
1354             len = WideCharToMultiByte(CP_ACP, 0, (const WCHAR *)privs, -1, NULL, 0, NULL, NULL);
1355             spn = HeapAlloc( GetProcessHeap(), 0, len );
1356             WideCharToMultiByte(CP_ACP, 0, (const WCHAR *)privs, -1, spn, len, NULL, NULL);
1357
1358             ok(!strcmp(domain_and_user, spn), "expected %s got %s\n", domain_and_user, spn);
1359             HeapFree( GetProcessHeap(), 0, spn );
1360         }
1361         ok(level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY, "level unchanged\n");
1362         ok(authnsvc == RPC_C_AUTHN_WINNT, "authnsvc unchanged\n");
1363
1364         status = RpcImpersonateClient(NULL);
1365         if (status == RPC_S_CANNOT_SUPPORT)
1366         {
1367             win_skip("RpcImpersonateClient not supported\n");
1368             return;
1369         }
1370         ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1371         status = RpcRevertToSelf();
1372         ok(status == RPC_S_OK, "expected RPC_S_OK got %u\n", status);
1373
1374     }
1375     else
1376     {
1377         status = RpcBindingInqAuthClientA(binding, &privs, &principal, &level, &authnsvc, NULL);
1378         ok(status == RPC_S_BINDING_HAS_NO_AUTH, "expected RPC_S_BINDING_HAS_NO_AUTH got %u\n", status);
1379         ok(privs == (RPC_AUTHZ_HANDLE)0xdeadbeef, "got %p\n", privs);
1380         ok(principal == (unsigned char *)0xdeadbeef, "got %s\n", principal);
1381         ok(level == 0xdeadbeef, "got %u\n", level);
1382         ok(authnsvc == 0xdeadbeef, "got %u\n", authnsvc);
1383     }
1384 }
1385
1386 static void
1387 run_tests(void)
1388 {
1389   basic_tests();
1390   union_tests();
1391   pointer_tests();
1392   array_tests();
1393   context_handle_test();
1394 }
1395
1396 static void
1397 set_auth_info(RPC_BINDING_HANDLE handle)
1398 {
1399     RPC_STATUS status;
1400     RPC_SECURITY_QOS qos;
1401
1402     if (!pGetUserNameExA)
1403         return;
1404
1405     qos.Version = 1;
1406     qos.Capabilities = RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH;
1407     qos.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
1408     qos.ImpersonationType = RPC_C_IMP_LEVEL_IMPERSONATE;
1409
1410     status = pRpcBindingSetAuthInfoExA(handle, (RPC_CSTR)domain_and_user, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
1411                                        RPC_C_AUTHN_WINNT, NULL, 0, &qos);
1412     ok(status == RPC_S_OK, "RpcBindingSetAuthInfoExA failed %d\n", status);
1413 }
1414
1415 static void
1416 client(const char *test)
1417 {
1418   static unsigned char iptcp[] = "ncacn_ip_tcp";
1419   static unsigned char np[] = "ncacn_np";
1420   static unsigned char ncalrpc[] = "ncalrpc";
1421   static unsigned char address[] = "127.0.0.1";
1422   static unsigned char address_np[] = "\\\\.";
1423   static unsigned char port[] = PORT;
1424   static unsigned char pipe[] = PIPE;
1425   static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1426
1427   unsigned char *binding;
1428
1429   if (strcmp(test, "tcp_basic") == 0)
1430   {
1431     ok(RPC_S_OK == RpcStringBindingCompose(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
1432     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1433
1434     run_tests();
1435     authinfo_test(RPC_PROTSEQ_TCP, 0);
1436
1437     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1438     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1439   }
1440   else if (strcmp(test, "tcp_secure") == 0)
1441   {
1442     ok(RPC_S_OK == RpcStringBindingCompose(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
1443     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1444
1445     set_auth_info(IServer_IfHandle);
1446     authinfo_test(RPC_PROTSEQ_TCP, 1);
1447
1448     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1449     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1450   }
1451   else if (strcmp(test, "ncalrpc_basic") == 0)
1452   {
1453     ok(RPC_S_OK == RpcStringBindingCompose(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1454     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1455
1456     run_tests(); /* can cause RPC_X_BAD_STUB_DATA exception */
1457     authinfo_test(RPC_PROTSEQ_LRPC, 0);
1458
1459     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1460     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1461   }
1462   else if (strcmp(test, "ncalrpc_secure") == 0)
1463   {
1464     ok(RPC_S_OK == RpcStringBindingCompose(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1465     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1466
1467     set_auth_info(IServer_IfHandle);
1468     authinfo_test(RPC_PROTSEQ_LRPC, 1);
1469
1470     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1471     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1472   }
1473   else if (strcmp(test, "np_basic") == 0)
1474   {
1475     ok(RPC_S_OK == RpcStringBindingCompose(NULL, np, address_np, pipe, NULL, &binding), "RpcStringBindingCompose\n");
1476     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1477
1478     run_tests();
1479     authinfo_test(RPC_PROTSEQ_NMP, 0);
1480     stop();
1481
1482     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1483     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1484   }
1485 }
1486
1487 static void
1488 server(void)
1489 {
1490   static unsigned char iptcp[] = "ncacn_ip_tcp";
1491   static unsigned char port[] = PORT;
1492   static unsigned char np[] = "ncacn_np";
1493   static unsigned char pipe[] = PIPE;
1494   static unsigned char ncalrpc[] = "ncalrpc";
1495   static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1496   RPC_STATUS status, iptcp_status, np_status, ncalrpc_status;
1497   DWORD ret;
1498
1499   iptcp_status = RpcServerUseProtseqEp(iptcp, 20, port, NULL);
1500   ok(iptcp_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_ip_tcp) failed with status %d\n", iptcp_status);
1501
1502   ncalrpc_status = RpcServerUseProtseqEp(ncalrpc, 0, guid, NULL);
1503   ok(ncalrpc_status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", ncalrpc_status);
1504
1505   np_status = RpcServerUseProtseqEp(np, 0, pipe, NULL);
1506   if (np_status == RPC_S_PROTSEQ_NOT_SUPPORTED)
1507     skip("Protocol sequence ncacn_np is not supported\n");
1508   else
1509     ok(np_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", np_status);
1510
1511   if (pRpcServerRegisterIfEx)
1512   {
1513     trace("Using RpcServerRegisterIfEx\n");
1514     status = pRpcServerRegisterIfEx(s_IServer_v0_0_s_ifspec, NULL, NULL,
1515                                     RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH,
1516                                     RPC_C_LISTEN_MAX_CALLS_DEFAULT, NULL);
1517   }
1518   else
1519     status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
1520   ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
1521   status = RpcServerListen(1, 20, TRUE);
1522   ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
1523   stop_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1524   ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
1525
1526   if (iptcp_status == RPC_S_OK)
1527     run_client("tcp_basic");
1528   else
1529     skip("tcp tests skipped due to earlier failure\n");
1530
1531   if (ncalrpc_status == RPC_S_OK)
1532   {
1533     run_client("ncalrpc_basic");
1534     if (pGetUserNameExA)
1535     {
1536       /* we don't need to register RPC_C_AUTHN_WINNT for ncalrpc */
1537       run_client("ncalrpc_secure");
1538     }
1539   }
1540   else
1541     skip("lrpc tests skipped due to earlier failure\n");
1542
1543   if (np_status == RPC_S_OK)
1544     run_client("np_basic");
1545   else
1546   {
1547     skip("np_basic tests skipped due to earlier failure\n");
1548     /* np client is what signals stop_event, so bail out if we didn't run do it */
1549     return;
1550   }
1551
1552   ret = WaitForSingleObject(stop_event, 1000);
1553   ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
1554   /* if the stop event didn't fire then RpcMgmtWaitServerListen will wait
1555    * forever, so don't bother calling it in this case */
1556   if (ret == WAIT_OBJECT_0)
1557   {
1558     status = RpcMgmtWaitServerListen();
1559     todo_wine {
1560       ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
1561     }
1562   }
1563 }
1564
1565 START_TEST(server)
1566 {
1567   int argc;
1568   char **argv;
1569
1570   InitFunctionPointers();
1571
1572   if (pGetUserNameExA)
1573   {
1574     ULONG size = 0;
1575     ok(!pGetUserNameExA(NameSamCompatible, NULL, &size), "GetUserNameExA\n");
1576     domain_and_user = HeapAlloc(GetProcessHeap(), 0, size);
1577     ok(pGetUserNameExA(NameSamCompatible, domain_and_user, &size), "GetUserNameExA\n");
1578   }
1579   else
1580     win_skip("GetUserNameExA is needed for some authentication tests\n");
1581
1582   argc = winetest_get_mainargs(&argv);
1583   progname = argv[0];
1584
1585   if (argc == 3)
1586   {
1587     RpcTryExcept
1588     {
1589       client(argv[2]);
1590     }
1591     RpcExcept(TRUE)
1592     {
1593       trace("Exception %d\n", RpcExceptionCode());
1594     }
1595     RpcEndExcept
1596   }
1597   else
1598     server();
1599
1600   HeapFree(GetProcessHeap(), 0, domain_and_user);
1601 }