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