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
  37 static HANDLE stop_event;
  38
  39 void __RPC_FAR *__RPC_USER
  40 midl_user_allocate(size_t n)
  41 {
  42   return malloc(n);
  43 }
  44
  45 void __RPC_USER
  46 midl_user_free(void __RPC_FAR *p)
  47 {
  48   free(p);
  49 }
  50
  51 int
  52 s_int_return(void)
  53 {
  54   return INT_CODE;
  55 }
  56
  57 int
  58 s_square(int x)
  59 {
  60   return x * x;
  61 }
  62
  63 int
  64 s_sum(int x, int y)
  65 {
  66   return x + y;
  67 }
  68
  69 void
  70 s_square_out(int x, int *y)
  71 {
  72   *y = s_square(x);
  73 }
  74
  75 void
  76 s_square_ref(int *x)
  77 {
  78   *x = s_square(*x);
  79 }
  80
  81 int
  82 s_str_length(const char *s)
  83 {
  84   return strlen(s);
  85 }
  86
  87 int
  88 s_dot_self(vector_t *v)
  89 {
  90   return s_square(v->x) + s_square(v->y) + s_square(v->z);
  91 }
  92
  93 double
  94 s_square_half(double x, double *y)
  95 {
  96   *y = x / 2.0;
  97   return x * x;
  98 }
  99
 100 float
 101 s_square_half_float(float x, float *y)
 102 {
 103   *y = x / 2.0f;
 104   return x * x;
 105 }
 106
 107 long
 108 s_square_half_long(long x, long *y)
 109 {
 110   *y = x / 2;
 111   return x * x;
 112 }
 113
 114 int
 115 s_sum_fixed_array(int a[5])
 116 {
 117   return a[0] + a[1] + a[2] + a[3] + a[4];
 118 }
 119
 120 int
 121 s_pints_sum(pints_t *pints)
 122 {
 123   return *pints->pi + **pints->ppi + ***pints->pppi;
 124 }
 125
 126 double
 127 s_ptypes_sum(ptypes_t *pt)
 128 {
 129   return *pt->pc + *pt->ps + *pt->pl + *pt->pf + *pt->pd;
 130 }
 131
 132 int
 133 s_dot_pvectors(pvectors_t *p)
 134 {
 135   return p->pu->x * (*p->pv)->x + p->pu->y * (*p->pv)->y + p->pu->z * (*p->pv)->z;
 136 }
 137
 138 int
 139 s_sum_sp(sp_t *sp)
 140 {
 141   return sp->x + sp->s->x;
 142 }
 143
 144 double
 145 s_square_sun(sun_t *su)
 146 {
 147   switch (su->s)
 148   {
 149   case SUN_I: return su->u.i * su->u.i;
 150   case SUN_F1:
 151   case SUN_F2: return su->u.f * su->u.f;
 152   case SUN_PI: return (*su->u.pi) * (*su->u.pi);
 153   default:
 154     return 0.0;
 155   }
 156 }
 157
 158 int
 159 s_test_list_length(test_list_t *list)
 160 {
 161   return (list->t == TL_LIST
 162           ? 1 + s_test_list_length(list->u.tail)
 163           : 0);
 164 }
 165
 166 int
 167 s_sum_fixed_int_3d(int m[2][3][4])
 168 {
 169   int i, j, k;
 170   int sum = 0;
 171
 172   for (i = 0; i < 2; ++i)
 173     for (j = 0; j < 3; ++j)
 174       for (k = 0; k < 4; ++k)
 175         sum += m[i][j][k];
 176
 177   return sum;
 178 }
 179
 180 int
 181 s_sum_conf_array(int x[], int n)
 182 {
 183   int *p = x, *end = p + n;
 184   int sum = 0;
 185
 186   while (p < end)
 187     sum += *p++;
 188
 189   return sum;
 190 }
 191
 192 int
 193 s_sum_var_array(int x[20], int n)
 194 {
 195   ok(0 <= n, "RPC sum_var_array\n");
 196   ok(n <= 20, "RPC sum_var_array\n");
 197
 198   return s_sum_conf_array(x, n);
 199 }
 200
 201 int
 202 s_dot_two_vectors(vector_t vs[2])
 203 {
 204   return vs[0].x * vs[1].x + vs[0].y * vs[1].y + vs[0].z * vs[1].z;
 205 }
 206
 207 int
 208 s_sum_cs(cs_t *cs)
 209 {
 210   return s_sum_conf_array(cs->ca, cs->n);
 211 }
 212
 213 int
 214 s_sum_cps(cps_t *cps)
 215 {
 216   int sum = 0;
 217   int i;
 218
 219   for (i = 0; i < *cps->pn; ++i)
 220     sum += cps->ca1[i];
 221
 222   for (i = 0; i < 2 * cps->n; ++i)
 223     sum += cps->ca2[i];
 224
 225   return sum;
 226 }
 227
 228 int
 229 s_square_puint(puint_t p)
 230 {
 231   int n = atoi(p);
 232   return n * n;
 233 }
 234
 235 int
 236 s_dot_copy_vectors(vector_t u, vector_t v)
 237 {
 238   return u.x * v.x + u.y * v.y + u.z * v.z;
 239 }
 240
 241 int
 242 s_square_test_us(test_us_t *tus)
 243 {
 244   int n = atoi(tus->us.x);
 245   return n * n;
 246 }
 247
 248 double
 249 s_square_encu(encu_t *eu)
 250 {
 251   switch (eu->t)
 252   {
 253   case ENCU_I: return eu->tagged_union.i * eu->tagged_union.i;
 254   case ENCU_F: return eu->tagged_union.f * eu->tagged_union.f;
 255   default:
 256     return 0.0;
 257   }
 258 }
 259
 260 int
 261 s_sum_parr(int *a[3])
 262 {
 263   return s_sum_pcarr(a, 3);
 264 }
 265
 266 int
 267 s_sum_pcarr(int *a[], int n)
 268 {
 269   int i, s = 0;
 270   for (i = 0; i < n; ++i)
 271     s += *a[i];
 272   return s;
 273 }
 274
 275 int
 276 s_enum_ord(e_t e)
 277 {
 278   switch (e)
 279   {
 280   case E1: return 1;
 281   case E2: return 2;
 282   case E3: return 3;
 283   case E4: return 4;
 284   default:
 285     return 0;
 286   }
 287 }
 288
 289 void
 290 s_stop(void)
 291 {
 292   ok(RPC_S_OK == RpcMgmtStopServerListening(NULL), "RpcMgmtStopServerListening\n");
 293   ok(RPC_S_OK == RpcServerUnregisterIf(NULL, NULL, FALSE), "RpcServerUnregisterIf\n");
 294   ok(SetEvent(stop_event), "SetEvent\n");
 295 }
 296
 297 static void
 298 make_cmdline(char buffer[MAX_PATH], const char *test)
 299 {
 300   sprintf(buffer, "%s server %s", progname, test);
 301 }
 302
 303 static int
 304 run_client(const char *test)
 305 {
 306   char cmdline[MAX_PATH];
 307   PROCESS_INFORMATION info;
 308   STARTUPINFOA startup;
 309   DWORD exitcode;
 310
 311   memset(&startup, 0, sizeof startup);
 312   startup.cb = sizeof startup;
 313
 314   make_cmdline(cmdline, test);
 315   ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 316   ok(WaitForSingleObject(info.hProcess, 30000) == WAIT_OBJECT_0, "Child process termination\n");
 317   ok(GetExitCodeProcess(info.hProcess, &exitcode), "GetExitCodeProcess\n");
 318   ok(CloseHandle(info.hProcess), "CloseHandle\n");
 319   ok(CloseHandle(info.hThread), "CloseHandle\n");
 320
 321   return exitcode == 0;
 322 }
 323
 324 static void
 325 basic_tests(void)
 326 {
 327   static char string[] = "I am a string";
 328   static int f[5] = {1, 3, 0, -2, -4};
 329   static vector_t a = {1, 3, 7};
 330   static vector_t vec1 = {4, -2, 1}, vec2 = {-5, 2, 3}, *pvec2 = &vec2;
 331   static pvectors_t pvecs = {&vec1, &pvec2};
 332   static sp_inner_t spi = {42};
 333   static sp_t sp = {-13, &spi};
 334   pints_t pints;
 335   ptypes_t ptypes;
 336   int i1, i2, i3, *pi2, *pi3, **ppi3;
 337   double u, v;
 338   float s, t;
 339   long q, r;
 340   short h;
 341   char c;
 342   int x;
 343
 344   ok(int_return() == INT_CODE, "RPC int_return\n");
 345
 346   ok(square(7) == 49, "RPC square\n");
 347   ok(sum(23, -4) == 19, "RPC sum\n");
 348
 349   x = 0;
 350   square_out(11, &x);
 351   ok(x == 121, "RPC square_out\n");
 352
 353   x = 5;
 354   square_ref(&x);
 355   ok(x == 25, "RPC square_ref\n");
 356
 357   ok(str_length(string) == strlen(string), "RPC str_length\n");
 358   ok(dot_self(&a) == 59, "RPC dot_self\n");
 359
 360   v = 0.0;
 361   u = square_half(3.0, &v);
 362   ok(u == 9.0, "RPC square_half\n");
 363   ok(v == 1.5, "RPC square_half\n");
 364
 365   t = 0.0f;
 366   s = square_half_float(3.0f, &t);
 367   ok(s == 9.0f, "RPC square_half_float\n");
 368   ok(t == 1.5f, "RPC square_half_float\n");
 369
 370   r = 0;
 371   q = square_half_long(3, &r);
 372   ok(q == 9, "RPC square_half_long\n");
 373   ok(r == 1, "RPC square_half_long\n");
 374
 375   i1 = 19;
 376   i2 = -3;
 377   i3 = -29;
 378   pi2 = &i2;
 379   pi3 = &i3;
 380   ppi3 = &pi3;
 381   pints.pi = &i1;
 382   pints.ppi = &pi2;
 383   pints.pppi = &ppi3;
 384   ok(pints_sum(&pints) == -13, "RPC pints_sum\n");
 385
 386   c = 10;
 387   h = 3;
 388   q = 14;
 389   s = -5.0f;
 390   u = 11.0;
 391   ptypes.pc = &c;
 392   ptypes.ps = &h;
 393   ptypes.pl = &q;
 394   ptypes.pf = &s;
 395   ptypes.pd = &u;
 396   ok(ptypes_sum(&ptypes) == 33.0, "RPC ptypes_sum\n");
 397
 398   ok(dot_pvectors(&pvecs) == -21, "RPC dot_pvectors\n");
 399   ok(dot_copy_vectors(vec1, vec2) == -21, "RPC dot_copy_vectors\n");
 400   ok(sum_fixed_array(f) == -2, "RPC sum_fixed_array\n");
 401   ok(sum_sp(&sp) == 29, "RPC sum_sp\n");
 402
 403   ok(enum_ord(E1) == 1, "RPC enum_ord\n");
 404   ok(enum_ord(E2) == 2, "RPC enum_ord\n");
 405   ok(enum_ord(E3) == 3, "RPC enum_ord\n");
 406   ok(enum_ord(E4) == 4, "RPC enum_ord\n");
 407 }
 408
 409 static void
 410 union_tests(void)
 411 {
 412   encu_t eu;
 413   sun_t su;
 414   int i;
 415
 416   su.s = SUN_I;
 417   su.u.i = 9;
 418   ok(square_sun(&su) == 81.0, "RPC square_sun\n");
 419
 420   su.s = SUN_F1;
 421   su.u.f = 5.0;
 422   ok(square_sun(&su) == 25.0, "RPC square_sun\n");
 423
 424   su.s = SUN_F2;
 425   su.u.f = -2.0;
 426   ok(square_sun(&su) == 4.0, "RPC square_sun\n");
 427
 428   su.s = SUN_PI;
 429   su.u.pi = &i;
 430   i = 11;
 431   ok(square_sun(&su) == 121.0, "RPC square_sun\n");
 432
 433   eu.t = ENCU_I;
 434   eu.tagged_union.i = 7;
 435   ok(square_encu(&eu) == 49.0, "RPC square_encu\n");
 436
 437   eu.t = ENCU_F;
 438   eu.tagged_union.f = 3.0;
 439   ok(square_encu(&eu) == 9.0, "RPC square_encu\n");
 440 }
 441
 442 static test_list_t *
 443 null_list(void)
 444 {
 445   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 446   n->t = TL_NULL;
 447   return n;
 448 }
 449
 450 static test_list_t *
 451 make_list(test_list_t *tail)
 452 {
 453   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 454   n->t = TL_LIST;
 455   n->u.tail = tail;
 456   return n;
 457 }
 458
 459 static void
 460 free_list(test_list_t *list)
 461 {
 462   if (list->t == TL_LIST)
 463     free_list(list->u.tail);
 464   HeapFree(GetProcessHeap(), 0, list);
 465 }
 466
 467 ULONG __RPC_USER
 468 puint_t_UserSize(ULONG *flags, ULONG start, puint_t *p)
 469 {
 470   return start + sizeof(int);
 471 }
 472
 473 unsigned char * __RPC_USER
 474 puint_t_UserMarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
 475 {
 476   int n = atoi(*p);
 477   memcpy(buffer, &n, sizeof n);
 478   return buffer + sizeof n;
 479 }
 480
 481 unsigned char * __RPC_USER
 482 puint_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
 483 {
 484   int n;
 485   memcpy(&n, buffer, sizeof n);
 486   *p = HeapAlloc(GetProcessHeap(), 0, 10);
 487   sprintf(*p, "%d", n);
 488   return buffer + sizeof n;
 489 }
 490
 491 void __RPC_USER
 492 puint_t_UserFree(ULONG *flags, puint_t *p)
 493 {
 494   HeapFree(GetProcessHeap(), 0, *p);
 495 }
 496
 497 ULONG __RPC_USER
 498 us_t_UserSize(ULONG *flags, ULONG start, us_t *pus)
 499 {
 500   return start + sizeof(struct wire_us);
 501 }
 502
 503 unsigned char * __RPC_USER
 504 us_t_UserMarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
 505 {
 506   struct wire_us wus;
 507   wus.x = atoi(pus->x);
 508   memcpy(buffer, &wus, sizeof wus);
 509   return buffer + sizeof wus;
 510 }
 511
 512 unsigned char * __RPC_USER
 513 us_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
 514 {
 515   struct wire_us wus;
 516   memcpy(&wus, buffer, sizeof wus);
 517   pus->x = HeapAlloc(GetProcessHeap(), 0, 10);
 518   sprintf(pus->x, "%d", wus.x);
 519   return buffer + sizeof wus;
 520 }
 521
 522 void __RPC_USER
 523 us_t_UserFree(ULONG *flags, us_t *pus)
 524 {
 525   HeapFree(GetProcessHeap(), 0, pus->x);
 526 }
 527
 528 static void
 529 pointer_tests(void)
 530 {
 531   static int a[] = {1, 2, 3, 4};
 532   static char p1[] = "11";
 533   test_list_t *list = make_list(make_list(make_list(null_list())));
 534   static test_us_t tus = {{p1}};
 535   int *pa[4];
 536
 537   ok(test_list_length(list) == 3, "RPC test_list_length\n");
 538   ok(square_puint(p1) == 121, "RPC square_puint\n");
 539   ok(square_test_us(&tus) == 121, "RPC square_test_us\n");
 540
 541   pa[0] = &a[0];
 542   pa[1] = &a[1];
 543   pa[2] = &a[2];
 544   ok(sum_parr(pa) == 6, "RPC sum_parr\n");
 545
 546   pa[0] = &a[0];
 547   pa[1] = &a[1];
 548   pa[2] = &a[2];
 549   pa[3] = &a[3];
 550   ok(sum_pcarr(pa, 4) == 10, "RPC sum_pcarr\n");
 551
 552   free_list(list);
 553 }
 554
 555 static void
 556 array_tests(void)
 557 {
 558   static int m[2][3][4] =
 559   {
 560     {{1, 2, 3, 4}, {-1, -3, -5, -7}, {0, 2, 4, 6}},
 561     {{1, -2, 3, -4}, {2, 3, 5, 7}, {-4, -1, -14, 4114}}
 562   };
 563   static int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 564   static vector_t vs[2] = {{1, -2, 3}, {4, -5, -6}};
 565   cps_t cps;
 566   cs_t *cs;
 567   int n;
 568
 569   ok(sum_fixed_int_3d(m) == 4116, "RPC sum_fixed_int_3d\n");
 570
 571   ok(sum_conf_array(c, 10) == 45, "RPC sum_conf_array\n");
 572   ok(sum_conf_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
 573   ok(sum_conf_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
 574   ok(sum_conf_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
 575
 576   ok(sum_var_array(c, 10) == 45, "RPC sum_conf_array\n");
 577   ok(sum_var_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
 578   ok(sum_var_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
 579   ok(sum_var_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
 580
 581   ok(dot_two_vectors(vs) == -4, "RPC dot_two_vectors\n");
 582   cs = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(cs_t, ca[5]));
 583   cs->n = 5;
 584   cs->ca[0] = 3;
 585   cs->ca[1] = 5;
 586   cs->ca[2] = -2;
 587   cs->ca[3] = -1;
 588   cs->ca[4] = -4;
 589   ok(sum_cs(cs) == 1, "RPC sum_cs\n");
 590   HeapFree(GetProcessHeap(), 0, cs);
 591
 592   n = 5;
 593   cps.pn = &n;
 594   cps.ca1 = &c[2];
 595   cps.n = 3;
 596   cps.ca2 = &c[3];
 597   ok(sum_cps(&cps) == 53, "RPC sum_cps\n");
 598 }
 599
 600 static void
 601 run_tests(void)
 602 {
 603   basic_tests();
 604   union_tests();
 605   pointer_tests();
 606   array_tests();
 607 }
 608
 609 static void
 610 client(const char *test)
 611 {
 612   if (strcmp(test, "tcp_basic") == 0)
 613   {
 614     static unsigned char iptcp[] = "ncacn_ip_tcp";
 615     static unsigned char address[] = "127.0.0.1";
 616     static unsigned char port[] = PORT;
 617     unsigned char *binding;
 618
 619     ok(RPC_S_OK == RpcStringBindingCompose(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
 620     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
 621
 622     run_tests();
 623
 624     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
 625     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
 626   }
 627   else if (strcmp(test, "np_basic") == 0)
 628   {
 629     static unsigned char np[] = "ncacn_np";
 630     static unsigned char address[] = "\\\\.";
 631     static unsigned char pipe[] = PIPE;
 632     unsigned char *binding;
 633
 634     ok(RPC_S_OK == RpcStringBindingCompose(NULL, np, address, pipe, NULL, &binding), "RpcStringBindingCompose\n");
 635     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
 636
 637     run_tests();
 638     stop();
 639
 640     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
 641     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
 642   }
 643 }
 644
 645 static void
 646 server(void)
 647 {
 648   static unsigned char iptcp[] = "ncacn_ip_tcp";
 649   static unsigned char port[] = PORT;
 650   static unsigned char np[] = "ncacn_np";
 651   static unsigned char pipe[] = PIPE;
 652
 653   ok(RPC_S_OK == RpcServerUseProtseqEp(iptcp, 20, port, NULL), "RpcServerUseProtseqEp\n");
 654   ok(RPC_S_OK == RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL), "RpcServerRegisterIf\n");
 655   ok(RPC_S_OK == RpcServerListen(1, 20, TRUE), "RpcServerListen\n");
 656
 657   stop_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 658   ok(stop_event != NULL, "CreateEvent failed\n");
 659
 660   ok(run_client("tcp_basic"), "tcp_basic client test failed\n");
 661
 662   ok(RPC_S_OK == RpcServerUseProtseqEp(np, 0, pipe, NULL), "RpcServerUseProtseqEp\n");
 663   ok(run_client("np_basic"), "np_basic client test failed\n");
 664
 665   ok(WAIT_OBJECT_0 == WaitForSingleObject(stop_event, 60000), "WaitForSingleObject\n");
 666   todo_wine {
 667     ok(RPC_S_OK == RpcMgmtWaitServerListen(), "RpcMgmtWaitServerListening\n");
 668   }
 669 }
 670
 671 START_TEST(server)
 672 {
 673   int argc;
 674   char **argv;
 675
 676   argc = winetest_get_mainargs(&argv);
 677   progname = argv[0];
 678
 679   if (argc == 3)
 680   {
 681     RpcTryExcept
 682     {
 683       client(argv[2]);
 684     }
 685     RpcExcept(TRUE)
 686     {
 687       trace("Exception %d\n", RpcExceptionCode());
 688     }
 689     RpcEndExcept
 690   }
 691   else
 692     server();
 693 }