testprogs/win32/midltests/midltests_tcp.c

   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] call[%d] plen[%d] ahint[%d]\n\n",
 105                       ctx, direction, hdr->frag_length, hdr->call_id,
 106                       len - 24, *(DWORD *)(&buf[0x10]));
 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] call[%d] plen[%d] ahint[%d]\n\n",
 114                        ctx, direction, hdr->frag_length, hdr->call_id,
 115                        len - 24, *(DWORD *)(&buf[0x10]));
 116                 dump_data(buf + 24, len - 24);
 117                 printf("\n");
 118                 fflush(stdout);
 119                 break;
 120
 121         case 3: /* fault */
 122                 printf("%s:%s: ptype[fault] flen[%d] call[%d] plen[%d]\n\n",
 123                        ctx, direction, hdr->ptype, hdr->frag_length, hdr->call_id,
 124                        len - 24);
 125                 dump_data(buf + 24, len - 24);
 126                 printf("\n");
 127                 fflush(stdout);
 128                 break;
 129
 130         case 11: /* bind */
 131 #if 0
 132                 printf("%s:%s: ptype[bind] flen[%d] call[%d] contexts[%d]\n\n"
 133                        ctx, direction, hdr->frag_length, hdr->call_id,
 134                        buf[24]);
 135                 dump_data(buf + 24, len - 24);
 136                 printf("\n");
 137                 fflush(stdout);
 138 #endif
 139                 break;
 140
 141         case 12: /* bind ack */
 142 #if 0
 143                 printf("%s:%s: ptype[bind_ack] flen[%d] call[%d]\n\n",
 144                        ctx, direction, hdr->frag_length, hdr->call_id);
 145                 fflush(stdout);
 146 #endif
 147                 break;
 148
 149         case 14: /* alter_req */
 150 #if 1
 151                 printf("%s:%s: ptype[alter_req] flen[%d] call[%d] contexts[%d]\n\n",
 152                            ctx, direction, hdr->frag_length, hdr->call_id,
 153                            buf[24]);
 154                 //dump_data(buf + 24, len - 24);
 155                 printf("\n");
 156                 fflush(stdout);
 157 #endif
 158                 break;
 159
 160         case 15: /* alter_ack */
 161 #if 1
 162                 printf("%s:%s: ptype[alter_ack] flen[%d] call[%d]\n\n",
 163                        ctx, direction, hdr->frag_length, hdr->call_id);
 164                 fflush(stdout);
 165 #endif
 166                 break;
 167
 168         default:
 169                 printf("%s:%s: ptype[%d] flen[%d] call[%d]\n\n",
 170                        ctx, direction, hdr->ptype, hdr->frag_length, hdr->call_id);
 171                 fflush(stdout);
 172                 break;
 173         }
 174 }
 175
 176 static void change_packet(const char *ctx, BOOL ndr64,
 177                           unsigned char *buf, int len)
 178 {
 179         struct dcerpc_header *hdr = (struct dcerpc_header *)buf;
 180         BOOL is_ndr64 = FALSE;
 181         const unsigned char ndr64_buf[] = {
 182                 0x33, 0x05, 0x71, 0x71, 0xBA, 0xBE, 0x37, 0x49,
 183                 0x83, 0x19, 0xB5, 0xDB, 0xEF, 0x9C, 0xCC, 0x36
 184         };
 185
 186         if (len < sizeof(struct dcerpc_header)) {
 187                 printf("%s: invalid dcerpc pdu len(%d)\n",
 188                            ctx, len);
 189                 fflush(stdout);
 190                 return;
 191         }
 192
 193         if (hdr->rpc_vers != 5 || hdr->rpc_vers_minor != 0) {
 194                 printf("%s: invalid dcerpc pdu len(%d) ver:%d min:%d\n",
 195                        ctx, len,
 196                        hdr->rpc_vers, hdr->rpc_vers_minor);
 197                 fflush(stdout);
 198                 return;
 199         }
 200
 201         if (hdr->frag_length != len) {
 202                 printf("%s: invalid dcerpc pdu len(%d) should be (%d)\n",
 203                        ctx, len, hdr->frag_length);
 204                 fflush(stdout);
 205                 return;
 206         }
 207
 208         switch (hdr->ptype) {
 209         case 11: /* bind */
 210         case 14: /* alter_req */
 211
 212                 if (buf[24] >= 2) {
 213                         int ret;
 214
 215                         ret = memcmp(&buf[0x60], ndr64_buf, 16);
 216                         if (ret == 0) {
 217                                 is_ndr64 = TRUE;
 218                         }
 219                 }
 220
 221                 if (is_ndr64 && !ndr64) {
 222                         buf[24+0x48] = 0xFF;
 223                         memset(&buf[0x60], 0xFF, 16);
 224                         printf("%s: disable NDR64\n\n", ctx);
 225                 } else if (!is_ndr64 && ndr64) {
 226                         printf("\n%s: got NDR32 downgrade\n\n", ctx);
 227 #ifndef DONOT_FORCE_NDR64
 228                         printf("\n\tERROR!!!\n\n");
 229                         memset(&buf[0x34], 0xFF, 16);
 230                         printf("You may need to run 'vcvarsall.bat amd64' before 'nmake tcp'\n");
 231 #endif
 232                         printf("\n");
 233                 } else if (is_ndr64) {
 234                         printf("%s: got NDR64\n\n", ctx);
 235                 } else {
 236                         printf("%s: got NDR32\n\n", ctx);
 237                 }
 238                 //printf("%s: bind with %u pres\n", ctx, buf[24]);
 239                 fflush(stdout);
 240                 break;
 241         }
 242 }
 243
 244 static int sock_pending(SOCKET s)
 245 {
 246         int ret, error;
 247         int value = 0;
 248         int len;
 249
 250         ret = ioctlsocket(s, FIONREAD, &value);
 251         if (ret == -1) {
 252                 return ret;
 253         }
 254
 255         if (ret != 0) {
 256                 /* this should not be reached */
 257                 return -1;
 258         }
 259
 260         if (value != 0) {
 261                 return value;
 262         }
 263
 264         error = 0;
 265         len = sizeof(error);
 266
 267         /*
 268          * if no data is available check if the socket is in error state. For
 269          * dgram sockets it's the way to return ICMP error messages of
 270          * connected sockets to the caller.
 271          */
 272         ret = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
 273         if (ret == -1) {
 274                 return ret;
 275         }
 276         if (error != 0) {
 277                 return -1;
 278         }
 279         return 0;
 280 }
 281
 282 DWORD WINAPI NDRProxyThread(LPVOID lpParameter)
 283 {
 284         struct NDRProxyThreadCtx *p = (struct NDRProxyThreadCtx *)lpParameter;
 285
 286         while (!p->ctx->stop) {
 287                 int r, s;
 288                 int ret = -1;
 289                 BYTE buf[5840];
 290
 291                 Sleep(250);
 292
 293                 ret = sock_pending(p->InSocket);
 294                 if (ret == 0) {
 295                         goto out;
 296                 }
 297
 298                 r = recv(p->InSocket, buf, sizeof(buf), 0);
 299                 if (r <= 0) {
 300                         ret = WSAGetLastError();
 301                         printf("%s: recv(in) failed[%d][%d]\n", p->ctx->name, r, ret);
 302                         fflush(stdout);
 303                         goto stop;
 304                 }
 305
 306                 change_packet(p->ctx->name, p->ctx->ndr64, buf, r);
 307                 fflush(stdout);
 308
 309                 dump_packet(p->ctx->name, "in => out", buf, r);
 310                 fflush(stdout);
 311
 312 out:
 313                 s = send(p->OutSocket, buf, r, 0);
 314                 if (s <= 0) {
 315                         ret = WSAGetLastError();
 316                         printf("%s: send(out) failed[%d][%d]\n", p->ctx->name, s, ret);
 317                         fflush(stdout);
 318                         goto stop;
 319                 }
 320
 321                 ret = sock_pending(p->OutSocket);
 322                 if (ret == 0) {
 323                         goto next;
 324                 }
 325
 326                 r = recv(p->OutSocket, buf, sizeof(buf), 0);
 327                 if (r <= 0) {
 328                         ret = WSAGetLastError();
 329                         printf("%s: recv(out) failed[%d][%d]\n", p->ctx->name, r, ret);
 330                         fflush(stdout);
 331                         goto stop;
 332                 }
 333
 334                 dump_packet(p->ctx->name, "out => in", buf, r);
 335                 fflush(stdout);
 336
 337                 s = send(p->InSocket, buf, r, 0);
 338                 if (s <= 0) {
 339                         ret = WSAGetLastError();
 340                         printf("%s: send(in) failed[%d][%d]\n", p->ctx->name, s, ret);
 341                         fflush(stdout);
 342                         goto stop;
 343                 }
 344 next:
 345                 continue;
 346         }
 347 stop:
 348         closesocket(p->InSocket);
 349         closesocket(p->OutSocket);
 350
 351         printf("NDRTcpThread[%s] stop\n", p->ctx->name);
 352         fflush(stdout);
 353         return 0;
 354 }
 355
 356 DWORD WINAPI NDRTcpThread(LPVOID lpParameter)
 357 {
 358         struct NDRTcpThreadCtx *ctx = (struct NDRTcpThreadCtx *)lpParameter;
 359         int ret = -1;
 360         SOCKET ListenSocket;
 361         struct sockaddr_in saServer;
 362         struct sockaddr_in saClient;
 363
 364         //printf("NDRTcpThread[%s] start\n", ctx->name);
 365         fflush(stdout);
 366
 367         ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 368         if (ListenSocket == INVALID_SOCKET) {
 369                 ret = WSAGetLastError();
 370                 printf("socket() failed[%d][%d]\n", ListenSocket, ret);
 371                 fflush(stdout);
 372                 goto failed;
 373         }
 374
 375         saServer.sin_family = AF_INET;
 376         saServer.sin_addr.s_addr = inet_addr(LISTEN_IP);
 377         saServer.sin_port = htons(ctx->listen_port);
 378
 379         saClient.sin_family = AF_INET;
 380         saClient.sin_addr.s_addr = inet_addr(FORWARD_IP);
 381         saClient.sin_port = htons(ctx->client_port);
 382
 383         ret = bind(ListenSocket, (SOCKADDR*)&saServer, sizeof(saServer));
 384         if (ret == SOCKET_ERROR) {
 385                 ret = WSAGetLastError();
 386                 printf("bind() failed[%d]\n", ret);
 387                 fflush(stdout);
 388                 goto failed;
 389         }
 390
 391         ret = listen(ListenSocket, 10);
 392         if (ret == SOCKET_ERROR) {
 393                 ret = WSAGetLastError();
 394                 printf("listen() failed[%d]\n", ret);
 395                 fflush(stdout);
 396                 goto failed;
 397         }
 398
 399         while (!ctx->stop) {
 400                 struct sockaddr_in sa;
 401                 int sa_len = sizeof(sa);
 402                 struct NDRProxyThreadCtx *p = malloc(sizeof(*p));
 403                 p->ctx = ctx;
 404
 405                 p->InSocket = accept(ListenSocket, (SOCKADDR *)&sa, &sa_len);
 406                 if (p->InSocket == INVALID_SOCKET) {
 407                         ret = WSAGetLastError();
 408                         printf("%s: accept() failed[%d][%d]\n", p->ctx->name, p->InSocket, ret);
 409                         fflush(stdout);
 410                         continue;
 411                 }
 412
 413                 p->OutSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 414                 if (p->OutSocket == INVALID_SOCKET) {
 415                         ret = WSAGetLastError();
 416                         printf("%s: socket(out) failed[%d][%d]\n", p->ctx->name, p->OutSocket, ret);
 417                         fflush(stdout);
 418                         closesocket(p->InSocket);
 419                         continue;
 420                 }
 421
 422                 ret = connect(p->OutSocket, (SOCKADDR*)&saClient, sizeof(saClient));
 423                 if (ret == SOCKET_ERROR) {
 424                         ret = WSAGetLastError();
 425                         printf("%s: connect() failed[%d]\n", p->ctx->name, ret);
 426                         fflush(stdout);
 427                         closesocket(p->InSocket);
 428                         closesocket(p->OutSocket);
 429                         continue;
 430                 }
 431
 432                 p->hThread = CreateThread(
 433                         NULL,           // default security attributes
 434                         0,              // use default stack size
 435                         NDRProxyThread, // thread function name
 436                         p,              // argument to thread function
 437                         0,              // use default creation flags
 438                         &p->dwThreadId);// returns the thread identifier
 439                 if (p->hThread == NULL) {
 440                         printf("failed to create thread ndr32\n");
 441                         fflush(stdout);
 442                         return -1;
 443                 }
 444         }
 445
 446         //printf("NDRTcpThread[%s] stop\n", ctx->name);
 447         fflush(stdout);
 448         return 0;
 449 failed:
 450         printf("NDRTcpThread[%s] failed[%d]\n", ctx->name, ret);
 451         fflush(stdout);
 452         return ret;
 453 }
 454
 455 struct NDRRpcThreadCtx {
 456         const char *name;
 457         short listen_port;
 458 };
 459
 460 DWORD WINAPI NDRRpcThread(LPVOID lpParameter)
 461 {
 462         struct NDRRpcThreadCtx *ctx = (struct NDRRpcThreadCtx *)lpParameter;
 463         int ret = -1;
 464         RPC_STATUS status;
 465         RPC_BINDING_VECTOR *pBindingVector;
 466
 467 #define RPC_MIN_CALLS 1
 468 #define RPC_MAX_CALLS 20
 469
 470         //printf("NDRRpcThread[%s] start\n", ctx->name);
 471         fflush(stdout);
 472         status = RpcServerUseProtseqEp("ncacn_ip_tcp", RPC_MAX_CALLS, "5055", NULL);
 473         if (status) {
 474                 printf("Failed to register ncacn_ip_tcp endpoint\n");
 475                 fflush(stdout);
 476                 return status;
 477         }
 478
 479         status = RpcServerInqBindings(&pBindingVector);
 480         if (status) {
 481                 printf("Failed RpcServerInqBindings\n");
 482                 fflush(stdout);
 483                 return status;
 484         }
 485
 486 #if 0
 487         status = RpcEpRegister(srv_midltests_v0_0_s_ifspec, pBindingVector, NULL, "midltests server");
 488         if (status) {
 489                 printf("Failed RpcEpRegister\n");
 490                 fflush(stdout);
 491                 return status;
 492         }
 493 #endif
 494         status = RpcServerRegisterIf(srv_midltests_v0_0_s_ifspec, NULL, NULL);
 495         if (status) {
 496                 printf("Failed to register interface\n");
 497                 fflush(stdout);
 498                 return status;
 499         }
 500
 501         status = RpcServerListen(RPC_MIN_CALLS, RPC_MAX_CALLS, FALSE);
 502         if (status) {
 503                 printf("RpcServerListen returned error %d\n", status);
 504                 fflush(stdout);
 505                 return status;
 506         }
 507
 508         printf("NDRRpcThread[%s] stop\n", ctx->name);
 509         fflush(stdout);
 510         return 0;
 511 failed:
 512         printf("NDRRpcThread[%s] failed[%d]\n", ctx->name, ret);
 513         fflush(stdout);
 514         return ret;
 515 }
 516
 517 int main(int argc, char **argv)
 518 {
 519         int ret;
 520         struct NDRTcpThreadCtx ctx_ndr32;
 521         struct NDRTcpThreadCtx ctx_ndr64;
 522         struct NDRRpcThreadCtx ctx_rpc;
 523         DWORD   dwThreadIdArray[3];
 524         HANDLE  hThreadArray[3];
 525         WORD wVersionRequested = MAKEWORD(2, 2);
 526         WSADATA wsaData;
 527         char *binding;
 528         RPC_STATUS status;
 529
 530         ret = WSAStartup(wVersionRequested, &wsaData);
 531         if (ret != 0) {
 532                 printf("WSAStartup failed with error: %d\n", ret);
 533                 fflush(stdout);
 534                 return -1;
 535         }
 536
 537         ctx_ndr32.name = "ndr32";
 538         ctx_ndr32.listen_port = 5032;
 539         ctx_ndr32.client_port = 5055;
 540         ctx_ndr32.ndr64 = FALSE;
 541         ctx_ndr32.stop = FALSE;
 542         hThreadArray[0] = CreateThread(
 543                 NULL,                   // default security attributes
 544                 0,                      // use default stack size
 545                 NDRTcpThread,           // thread function name
 546                 &ctx_ndr32,             // argument to thread function
 547                 0,                      // use default creation flags
 548                 &dwThreadIdArray[0]);   // returns the thread identifier
 549         if (hThreadArray[0] == NULL) {
 550                 printf("failed to create thread ndr32\n");
 551                 fflush(stdout);
 552                 return -1;
 553         }
 554
 555         ctx_ndr64.name = "ndr64";
 556         ctx_ndr64.listen_port = 5064;
 557         ctx_ndr64.client_port = 5055;
 558         ctx_ndr64.ndr64 = TRUE;
 559         ctx_ndr64.stop = FALSE;
 560         hThreadArray[1] = CreateThread(
 561                 NULL,                   // default security attributes
 562                 0,                      // use default stack size
 563                 NDRTcpThread,           // thread function name
 564                 &ctx_ndr64,             // argument to thread function
 565                 0,                      // use default creation flags
 566                 &dwThreadIdArray[1]);   // returns the thread identifier
 567         if (hThreadArray[1] == NULL) {
 568                 printf("failed to create thread ndr64\n");
 569                 fflush(stdout);
 570                 return -1;
 571         }
 572
 573         ctx_rpc.name = "rpc";
 574         ctx_rpc.listen_port = 5050;
 575         hThreadArray[2] = CreateThread(
 576                 NULL,                   // default security attributes
 577                 0,                      // use default stack size
 578                 NDRRpcThread,           // thread function name
 579                 &ctx_rpc,               // argument to thread function
 580                 0,                      // use default creation flags
 581                 &dwThreadIdArray[2]);   // returns the thread identifier
 582         if (hThreadArray[2] == NULL) {
 583                 printf("failed to create thread rpc\n");
 584                 fflush(stdout);
 585                 return -1;
 586         }
 587
 588         printf("Wait for setup of server threads\n");
 589         fflush(stdout);
 590         ret = WaitForMultipleObjects(3, hThreadArray, TRUE, 3000);
 591         if (ret == WAIT_TIMEOUT) {
 592                 /* OK */
 593         } else {
 594                 printf("Failed to setup of server threads %d:%d\n",
 595                         ret, GetLastError());
 596                 fflush(stdout);
 597                 return -1;
 598         }
 599         ret = 0;
 600
 601         printf("\nTest NDR32\n\n");
 602         fflush(stdout);
 603         binding = "ncacn_ip_tcp:" CONNECT_IP "[5032]";
 604         status = RpcBindingFromStringBinding(
 605                         binding,
 606                         &midltests_IfHandle);
 607         if (status) {
 608                 printf("RpcBindingFromStringBinding returned %d\n", status);
 609                 fflush(stdout);
 610                 return status;
 611         }
 612
 613         RpcTryExcept {
 614                 midltests();
 615         } RpcExcept(1) {
 616                 ret = RpcExceptionCode();
 617                 printf("NDR32 Runtime error 0x%x\n", ret);
 618                 fflush(stdout);
 619         } RpcEndExcept
 620         ctx_ndr32.stop = TRUE;
 621
 622         Sleep(250);
 623
 624         printf("\nTest NDR64\n\n");
 625         binding = "ncacn_ip_tcp:" CONNECT_IP "[5064]";
 626         status = RpcBindingFromStringBinding(
 627                         binding,
 628                         &midltests_IfHandle);
 629         if (status) {
 630                 printf("RpcBindingFromStringBinding returned %d\n", status);
 631                 fflush(stdout);
 632                 return status;
 633         }
 634
 635         RpcTryExcept {
 636                 midltests();
 637         } RpcExcept(1) {
 638                 ret = RpcExceptionCode();
 639                 printf("Runtime error 0x%x\n", ret);
 640                 fflush(stdout);
 641         } RpcEndExcept
 642         ctx_ndr64.stop = TRUE;
 643
 644         WaitForMultipleObjects(3, hThreadArray, TRUE, 2000);
 645
 646         if (ret == 0) {
 647                 printf("\nTest OK\n");
 648                 fflush(stdout);
 649         } else {
 650                 printf("\nTest FAILED[%d]\n", ret);
 651                 fflush(stdout);
 652         }
 653
 654         return ret;
 655 }