?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
midltests: make it possible to allow downgrades to NDR32
[Samba/gebeck_regimport.git] / testprogs / win32 / midltests / midltests_tcp.c
blob41a698c3a95e257d32df554aed895bebfc7ab3e3
1 /*
2 MIDLTESTS client.
3
4 Copyright (C) Stefan Metzmacher 2008
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program 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
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <ctype.h>
23 #include <winsock.h>
24 #include "midltests.h"
25
26 #ifndef _M_AMD64
27 #error "please run 'vcvarsall.bat amd64' -midltests_tcp needs 64-bit support!"
28 #endif
29
30 #define MIDLTESTS_C_CODE 1
31 #include "midltests.idl"
32
33 #ifndef LISTEN_IP
34 #define LISTEN_IP "127.0.0.1"
35 #endif
36
37 #ifndef FORWARD_IP
38 #define FORWARD_IP "127.0.0.1"
39 #endif
40
41 #ifndef CONNECT_IP
42 #define CONNECT_IP "127.0.0.1"
43 #endif
44
45 struct NDRTcpThreadCtx;
46
47 struct NDRProxyThreadCtx {
48 const struct NDRTcpThreadCtx *ctx;
49 SOCKET InSocket;
50 SOCKET OutSocket;
51 DWORD dwThreadId;
52 HANDLE hThread;
53 };
54
55 struct NDRTcpThreadCtx {
56 const char *name;
57 short listen_port;
58 short client_port;
59 BOOL ndr64;
60 BOOL stop;
61 };
62
63 struct dcerpc_header {
64 BYTE rpc_vers; /* RPC version */
65 BYTE rpc_vers_minor; /* Minor version */
66 BYTE ptype; /* Packet type */
67 BYTE pfc_flags; /* Fragmentation flags */
68 BYTE drep[4]; /* NDR data representation */
69 short frag_length; /* Total length of fragment */
70 short auth_length; /* authenticator length */
71 DWORD call_id; /* Call identifier */
72 };
73
74 static void dump_packet(const char *ctx, const char *direction,
75 const unsigned char *buf, int len)
76 {
77 struct dcerpc_header *hdr = (struct dcerpc_header *)buf;
78
79 if (len < sizeof(struct dcerpc_header)) {
80 printf("%s:%s: invalid dcerpc pdu len(%d)\n",
81 ctx, direction, len);
82 fflush(stdout);
83 return;
84 }
85
86 if (hdr->rpc_vers != 5 || hdr->rpc_vers_minor != 0) {
87 printf("%s:%s: invalid dcerpc pdu len(%d) ver:%d min:%d\n",
88 ctx, direction, len,
89 hdr->rpc_vers, hdr->rpc_vers_minor);
90 fflush(stdout);
91 return;
92 }
93
94 if (hdr->frag_length != len) {
95 printf("%s:%s: invalid dcerpc pdu len(%d) should be (%d)\n",
96 ctx, direction, len, hdr->frag_length);
97 fflush(stdout);
98 return;
99 }
100
101
102 switch (hdr->ptype) {
103 case 0: /* request */
104 printf("%s:%s: ptype[request] flen[%d] plen[%d]\n\n",
105 ctx, direction, hdr->frag_length,
106 len - 24);
107 dump_data(buf + 24, len - 24);
108 printf("\n");
109 fflush(stdout);
110 break;
111
112 case 2: /* response */
113 printf("\n%s:%s: ptype[response] flen[%d] plen[%d]\n\n",
114 ctx, direction, hdr->frag_length,
115 len - 24);
116 dump_data(buf + 24, len - 24);
117 printf("\n");
118 fflush(stdout);
119 break;
120
121 case 11: /* bind */
122 #if 0
123 printf("%s:%s: ptype[bind] flen[%d] call[%d] contexts[%d]\n\n"
124 ctx, direction, hdr->frag_length, hdr->call_id,
125 buf[24]);
126 dump_data(buf + 24, len - 24);
127 printf("\n");
128 fflush(stdout);
129 #endif
130 break;
131
132 case 12: /* bind ack */
133 #if 0
134 printf("%s:%s: ptype[bind_ack] flen[%d] call[%d]\n\n",
135 ctx, direction, hdr->frag_length, hdr->call_id);
136 fflush(stdout);
137 #endif
138 break;
139
140 case 14: /* alter_req */
141 #if 1
142 printf("%s:%s: ptype[alter_req] flen[%d] call[%d] contexts[%d]\n\n",
143 ctx, direction, hdr->frag_length, hdr->call_id,
144 buf[24]);
145 //dump_data(buf + 24, len - 24);
146 printf("\n");
147 fflush(stdout);
148 #endif
149 break;
150
151 case 15: /* alter_ack */
152 #if 1
153 printf("%s:%s: ptype[alter_ack] flen[%d] call[%d]\n\n",
154 ctx, direction, hdr->frag_length, hdr->call_id);
155 fflush(stdout);
156 #endif
157 break;
158
159 default:
160 printf("%s:%s: ptype[%d] flen[%d] call[%d]\n\n",
161 ctx, direction, hdr->ptype, hdr->frag_length, hdr->call_id);
162 fflush(stdout);
163 break;
164 }
165 }
166
167 static void change_packet(const char *ctx, BOOL ndr64,
168 unsigned char *buf, int len)
169 {
170 struct dcerpc_header *hdr = (struct dcerpc_header *)buf;
171
172 if (len < sizeof(struct dcerpc_header)) {
173 printf("%s: invalid dcerpc pdu len(%d)\n",
174 ctx, len);
175 fflush(stdout);
176 return;
177 }
178
179 if (hdr->rpc_vers != 5 || hdr->rpc_vers_minor != 0) {
180 printf("%s: invalid dcerpc pdu len(%d) ver:%d min:%d\n",
181 ctx, len,
182 hdr->rpc_vers, hdr->rpc_vers_minor);
183 fflush(stdout);
184 return;
185 }
186
187 if (hdr->frag_length != len) {
188 printf("%s: invalid dcerpc pdu len(%d) should be (%d)\n",
189 ctx, len, hdr->frag_length);
190 fflush(stdout);
191 return;
192 }
193
194 switch (hdr->ptype) {
195 case 11: /* bind */
196 if (buf[24] == 3 && !ndr64) {
197 buf[24+0x48] = 0xFF;
198 printf("%s: disable NDR64\n\n", ctx);
199 } else if (buf[24] < 3 && ndr64) {
200 printf("\n%s: got NDR32 downgrade\n\n", ctx);
201 #ifndef DONOT_FORCE_NDR64
202 printf("\n\tERROR!!!\n\n");
203 buf[24] = 0x00;
204 printf("You may need to run 'vcvarsall.bat amd64' before 'nmake tcp'\n");
205 #endif
206 printf("\n");
207 } else if (buf[24] == 3 && ndr64) {
208 printf("%s: got NDR64\n\n", ctx);
209 } else {
210 printf("%s: got NDR32\n\n", ctx);
211 }
212 //printf("%s: bind with %u pres\n", ctx, buf[24]);
213 fflush(stdout);
214 break;
215 }
216 }
217
218 DWORD WINAPI NDRProxyThread(LPVOID lpParameter)
219 {
220 struct NDRProxyThreadCtx *p = (struct NDRProxyThreadCtx *)lpParameter;
221
222 while (!p->ctx->stop) {
223 int r, s;
224 int ret = -1;
225 BYTE buf[5840];
226
227 r = recv(p->InSocket, buf, sizeof(buf), 0);
228 if (r <= 0) {
229 ret = WSAGetLastError();
230 printf("%s: recv(in) failed[%d][%d]\n", p->ctx->name, r, ret);
231 fflush(stdout);
232 goto next;
233 }
234
235 change_packet(p->ctx->name, p->ctx->ndr64, buf, r);
236 fflush(stdout);
237
238 dump_packet(p->ctx->name, "in => out", buf, r);
239 fflush(stdout);
240
241 s = send(p->OutSocket, buf, r, 0);
242 if (s <= 0) {
243 ret = WSAGetLastError();
244 printf("%s: send(out) failed[%d][%d]\n", p->ctx->name, s, ret);
245 fflush(stdout);
246 goto next;
247 }
248
249 r = recv(p->OutSocket, buf, sizeof(buf), 0);
250 if (r <= 0) {
251 ret = WSAGetLastError();
252 printf("%s: recv(out) failed[%d][%d]\n", p->ctx->name, r, ret);
253 fflush(stdout);
254 goto next;
255 }
256
257 dump_packet(p->ctx->name, "out => in", buf, r);
258 fflush(stdout);
259
260 s = send(p->InSocket, buf, r, 0);
261 if (s <= 0) {
262 ret = WSAGetLastError();
263 printf("%s: send(in) failed[%d][%d]\n", p->ctx->name, s, ret);
264 fflush(stdout);
265 goto next;
266 }
267
268 }
269 next:
270 closesocket(p->InSocket);
271 closesocket(p->OutSocket);
272
273 printf("NDRTcpThread[%s] stop\n", p->ctx->name);
274 fflush(stdout);
275 return 0;
276 }
277
278 DWORD WINAPI NDRTcpThread(LPVOID lpParameter)
279 {
280 struct NDRTcpThreadCtx *ctx = (struct NDRTcpThreadCtx *)lpParameter;
281 int ret = -1;
282 SOCKET ListenSocket;
283 struct sockaddr_in saServer;
284 struct sockaddr_in saClient;
285
286 //printf("NDRTcpThread[%s] start\n", ctx->name);
287 fflush(stdout);
288
289 ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
290 if (ListenSocket == INVALID_SOCKET) {
291 ret = WSAGetLastError();
292 printf("socket() failed[%d][%d]\n", ListenSocket, ret);
293 fflush(stdout);
294 goto failed;
295 }
296
297 saServer.sin_family = AF_INET;
298 saServer.sin_addr.s_addr = inet_addr(LISTEN_IP);
299 saServer.sin_port = htons(ctx->listen_port);
300
301 saClient.sin_family = AF_INET;
302 saClient.sin_addr.s_addr = inet_addr(FORWARD_IP);
303 saClient.sin_port = htons(ctx->client_port);
304
305 ret = bind(ListenSocket, (SOCKADDR*)&saServer, sizeof(saServer));
306 if (ret == SOCKET_ERROR) {
307 ret = WSAGetLastError();
308 printf("bind() failed[%d]\n", ret);
309 fflush(stdout);
310 goto failed;
311 }
312
313 ret = listen(ListenSocket, 10);
314 if (ret == SOCKET_ERROR) {
315 ret = WSAGetLastError();
316 printf("listen() failed[%d]\n", ret);
317 fflush(stdout);
318 goto failed;
319 }
320
321 while (!ctx->stop) {
322 struct sockaddr_in sa;
323 int sa_len = sizeof(sa);
324 struct NDRProxyThreadCtx *p = malloc(sizeof(*p));
325 p->ctx = ctx;
326
327 p->InSocket = accept(ListenSocket, (SOCKADDR *)&sa, &sa_len);
328 if (p->InSocket == INVALID_SOCKET) {
329 ret = WSAGetLastError();
330 printf("%s: accept() failed[%d][%d]\n", p->ctx->name, p->InSocket, ret);
331 fflush(stdout);
332 continue;
333 }
334
335 p->OutSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
336 if (p->OutSocket == INVALID_SOCKET) {
337 ret = WSAGetLastError();
338 printf("%s: socket(out) failed[%d][%d]\n", p->ctx->name, p->OutSocket, ret);
339 fflush(stdout);
340 closesocket(p->InSocket);
341 continue;
342 }
343
344 ret = connect(p->OutSocket, (SOCKADDR*)&saClient, sizeof(saClient));
345 if (ret == SOCKET_ERROR) {
346 ret = WSAGetLastError();
347 printf("%s: connect() failed[%d]\n", p->ctx->name, ret);
348 fflush(stdout);
349 closesocket(p->InSocket);
350 closesocket(p->OutSocket);
351 continue;
352 }
353
354 p->hThread = CreateThread(
355 NULL, // default security attributes
356 0, // use default stack size
357 NDRProxyThread, // thread function name
358 p, // argument to thread function
359 0, // use default creation flags
360 &p->dwThreadId);// returns the thread identifier
361 if (p->hThread == NULL) {
362 printf("failed to create thread ndr32\n");
363 fflush(stdout);
364 return -1;
365 }
366 }
367
368 //printf("NDRTcpThread[%s] stop\n", ctx->name);
369 fflush(stdout);
370 return 0;
371 failed:
372 printf("NDRTcpThread[%s] failed[%d]\n", ctx->name, ret);
373 fflush(stdout);
374 return ret;
375 }
376
377 struct NDRRpcThreadCtx {
378 const char *name;
379 short listen_port;
380 };
381
382 DWORD WINAPI NDRRpcThread(LPVOID lpParameter)
383 {
384 struct NDRRpcThreadCtx *ctx = (struct NDRRpcThreadCtx *)lpParameter;
385 int ret = -1;
386 RPC_STATUS status;
387 RPC_BINDING_VECTOR *pBindingVector;
388
389 #define RPC_MIN_CALLS 1
390 #define RPC_MAX_CALLS 20
391
392 //printf("NDRRpcThread[%s] start\n", ctx->name);
393 fflush(stdout);
394 status = RpcServerUseProtseqEp("ncacn_ip_tcp", RPC_MAX_CALLS, "5055", NULL);
395 if (status) {
396 printf("Failed to register ncacn_ip_tcp endpoint\n");
397 fflush(stdout);
398 return status;
399 }
400
401 status = RpcServerInqBindings(&pBindingVector);
402 if (status) {
403 printf("Failed RpcServerInqBindings\n");
404 fflush(stdout);
405 return status;
406 }
407
408 #if 0
409 status = RpcEpRegister(srv_midltests_v0_0_s_ifspec, pBindingVector, NULL, "midltests server");
410 if (status) {
411 printf("Failed RpcEpRegister\n");
412 fflush(stdout);
413 return status;
414 }
415 #endif
416 status = RpcServerRegisterIf(srv_midltests_v0_0_s_ifspec, NULL, NULL);
417 if (status) {
418 printf("Failed to register interface\n");
419 fflush(stdout);
420 return status;
421 }
422
423 status = RpcServerListen(RPC_MIN_CALLS, RPC_MAX_CALLS, FALSE);
424 if (status) {
425 printf("RpcServerListen returned error %d\n", status);
426 fflush(stdout);
427 return status;
428 }
429
430 printf("NDRRpcThread[%s] stop\n", ctx->name);
431 fflush(stdout);
432 return 0;
433 failed:
434 printf("NDRRpcThread[%s] failed[%d]\n", ctx->name, ret);
435 fflush(stdout);
436 return ret;
437 }
438
439 int main(int argc, char **argv)
440 {
441 int ret;
442 struct NDRTcpThreadCtx ctx_ndr32;
443 struct NDRTcpThreadCtx ctx_ndr64;
444 struct NDRRpcThreadCtx ctx_rpc;
445 DWORD dwThreadIdArray[3];
446 HANDLE hThreadArray[3];
447 WORD wVersionRequested = MAKEWORD(2, 2);
448 WSADATA wsaData;
449 char *binding;
450 RPC_STATUS status;
451
452 ret = WSAStartup(wVersionRequested, &wsaData);
453 if (ret != 0) {
454 printf("WSAStartup failed with error: %d\n", ret);
455 fflush(stdout);
456 return -1;
457 }
458
459 ctx_ndr32.name = "ndr32";
460 ctx_ndr32.listen_port = 5032;
461 ctx_ndr32.client_port = 5055;
462 ctx_ndr32.ndr64 = FALSE;
463 ctx_ndr32.stop = FALSE;
464 hThreadArray[0] = CreateThread(
465 NULL, // default security attributes
466 0, // use default stack size
467 NDRTcpThread, // thread function name
468 &ctx_ndr32, // argument to thread function
469 0, // use default creation flags
470 &dwThreadIdArray[0]); // returns the thread identifier
471 if (hThreadArray[0] == NULL) {
472 printf("failed to create thread ndr32\n");
473 fflush(stdout);
474 return -1;
475 }
476
477 ctx_ndr64.name = "ndr64";
478 ctx_ndr64.listen_port = 5064;
479 ctx_ndr64.client_port = 5055;
480 ctx_ndr64.ndr64 = TRUE;
481 ctx_ndr64.stop = FALSE;
482 hThreadArray[1] = CreateThread(
483 NULL, // default security attributes
484 0, // use default stack size
485 NDRTcpThread, // thread function name
486 &ctx_ndr64, // argument to thread function
487 0, // use default creation flags
488 &dwThreadIdArray[1]); // returns the thread identifier
489 if (hThreadArray[1] == NULL) {
490 printf("failed to create thread ndr64\n");
491 fflush(stdout);
492 return -1;
493 }
494
495 ctx_rpc.name = "rpc";
496 ctx_rpc.listen_port = 5050;
497 hThreadArray[2] = CreateThread(
498 NULL, // default security attributes
499 0, // use default stack size
500 NDRRpcThread, // thread function name
501 &ctx_rpc, // argument to thread function
502 0, // use default creation flags
503 &dwThreadIdArray[2]); // returns the thread identifier
504 if (hThreadArray[2] == NULL) {
505 printf("failed to create thread rpc\n");
506 fflush(stdout);
507 return -1;
508 }
509
510 printf("Wait for setup of server threads\n");
511 fflush(stdout);
512 ret = WaitForMultipleObjects(3, hThreadArray, TRUE, 3000);
513 if (ret == WAIT_TIMEOUT) {
514 /* OK */
515 } else {
516 printf("Failed to setup of server threads %d:%d\n",
517 ret, GetLastError());
518 fflush(stdout);
519 return -1;
520 }
521 ret = 0;
522
523 printf("\nTest NDR32\n\n");
524 fflush(stdout);
525 binding = "ncacn_ip_tcp:" CONNECT_IP "[5032]";
526 status = RpcBindingFromStringBinding(
527 binding,
528 &midltests_IfHandle);
529 if (status) {
530 printf("RpcBindingFromStringBinding returned %d\n", status);
531 fflush(stdout);
532 return status;
533 }
534
535 RpcTryExcept {
536 midltests();
537 } RpcExcept(1) {
538 ret = RpcExceptionCode();
539 printf("NDR32 Runtime error 0x%x\n", ret);
540 fflush(stdout);
541 } RpcEndExcept
542 ctx_ndr32.stop = TRUE;
543
544 Sleep(250);
545
546 printf("\nTest NDR64\n\n");
547 binding = "ncacn_ip_tcp:" CONNECT_IP "[5064]";
548 status = RpcBindingFromStringBinding(
549 binding,
550 &midltests_IfHandle);
551 if (status) {
552 printf("RpcBindingFromStringBinding returned %d\n", status);
553 fflush(stdout);
554 return status;
555 }
556
557 RpcTryExcept {
558 midltests();
559 } RpcExcept(1) {
560 ret = RpcExceptionCode();
561 printf("Runtime error 0x%x\n", ret);
562 fflush(stdout);
563 } RpcEndExcept
564 ctx_ndr64.stop = TRUE;
565
566 WaitForMultipleObjects(3, hThreadArray, TRUE, 2000);
567
568 if (ret == 0) {
569 printf("\nTest OK\n");
570 fflush(stdout);
571 } else {
572 printf("\nTest FAILED[%d]\n", ret);
573 fflush(stdout);
574 }
575
576 return ret;
577 }
reg import