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