source4/torture/rpc/echo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for echo rpc operations
   4
   5    Copyright (C) Andrew Tridgell 2003
   6    Copyright (C) Stefan (metze) Metzmacher 2005
   7    Copyright (C) Jelmer Vernooij 2005
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "torture/torture.h"
  26 #include "torture/rpc/rpc.h"
  27 #include "lib/events/events.h"
  28 #include "librpc/gen_ndr/ndr_echo.h"
  29
  30
  31 /*
  32   test the AddOne interface
  33 */
  34 #define TEST_ADDONE(value) do { \
  35         n = i = value; \
  36         r.in.in_data = n; \
  37         r.out.out_data = &n; \
  38         status = dcerpc_echo_AddOne(p, mem_ctx, &r); \
  39         if (!NT_STATUS_IS_OK(status)) { \
  40                 printf("AddOne(%d) failed - %s\n", i, nt_errstr(status)); \
  41                 return False; \
  42         } \
  43         if (n != i+1) { \
  44                 printf("%d + 1 != %u (should be %u)\n", i, n, i+1); \
  45                 ret = False; \
  46         } else { \
  47                 printf("%d + 1 = %u\n", i, n); \
  48         } \
  49 } while(0)
  50
  51 static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  52 {
  53         BOOL ret = True;
  54         uint32_t i;
  55         NTSTATUS status;
  56         uint32_t n;
  57         struct echo_AddOne r;
  58
  59         printf("\nTesting AddOne\n");
  60
  61         for (i=0;i<10;i++) {
  62                 TEST_ADDONE(i);
  63         }
  64
  65         TEST_ADDONE(0x7FFFFFFE);
  66         TEST_ADDONE(0xFFFFFFFE);
  67         TEST_ADDONE(0xFFFFFFFF);
  68         TEST_ADDONE(random() & 0xFFFFFFFF);
  69
  70         return ret;
  71 }
  72
  73 /*
  74   test the EchoData interface
  75 */
  76 static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  77 {
  78         int i;
  79         NTSTATUS status;
  80         uint8_t *data_in, *data_out;
  81         int len;
  82         struct echo_EchoData r;
  83
  84         if (lp_parm_bool(-1, "torture", "quick", False) &&
  85             (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
  86                 len = 1 + (random() % 500);
  87         } else {
  88                 len = 1 + (random() % 5000);
  89         }
  90
  91         printf("\nTesting EchoData\n");
  92
  93         data_in = talloc_size(mem_ctx, len);
  94         data_out = talloc_size(mem_ctx, len);
  95         for (i=0;i<len;i++) {
  96                 data_in[i] = i;
  97         }
  98
  99         r.in.len = len;
 100         r.in.in_data = data_in;
 101
 102         status = dcerpc_echo_EchoData(p, mem_ctx, &r);
 103         if (!NT_STATUS_IS_OK(status)) {
 104                 printf("EchoData(%d) failed - %s\n", len, nt_errstr(status));
 105                 return False;
 106         }
 107
 108         data_out = r.out.out_data;
 109
 110         for (i=0;i<len;i++) {
 111                 if (data_in[i] != data_out[i]) {
 112                         printf("Bad data returned for len %d at offset %d\n",
 113                                len, i);
 114                         printf("in:\n");
 115                         dump_data(0, data_in+i, MIN(len-i, 16));
 116                         printf("out:\n");
 117                         dump_data(0, data_out+i, MIN(len-1, 16));
 118                         return False;
 119                 }
 120         }
 121
 122
 123         return True;
 124 }
 125
 126
 127 /*
 128   test the SourceData interface
 129 */
 130 static BOOL test_sourcedata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 131 {
 132         int i;
 133         NTSTATUS status;
 134         int len;
 135         struct echo_SourceData r;
 136
 137         if (lp_parm_bool(-1, "torture", "quick", False) &&
 138             (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
 139                 len = 100 + (random() % 500);
 140         } else {
 141                 len = 200000 + (random() % 5000);
 142         }
 143
 144         printf("\nTesting SourceData\n");
 145
 146         r.in.len = len;
 147
 148         status = dcerpc_echo_SourceData(p, mem_ctx, &r);
 149         if (!NT_STATUS_IS_OK(status)) {
 150                 printf("SourceData(%d) failed - %s\n", len, nt_errstr(status));
 151                 return False;
 152         }
 153
 154         for (i=0;i<len;i++) {
 155                 uint8_t *v = (uint8_t *)r.out.data;
 156                 if (v[i] != (i & 0xFF)) {
 157                         printf("bad data 0x%x at %d\n", (uint8_t)r.out.data[i], i);
 158                         return False;
 159                 }
 160         }
 161
 162         return True;
 163 }
 164
 165 /*
 166   test the SinkData interface
 167 */
 168 static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 169 {
 170         int i;
 171         NTSTATUS status;
 172         uint8_t *data_in;
 173         int len;
 174         struct echo_SinkData r;
 175
 176         if (lp_parm_bool(-1, "torture", "quick", False) &&
 177             (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
 178                 len = 100 + (random() % 5000);
 179         } else {
 180                 len = 200000 + (random() % 5000);
 181         }
 182
 183         printf("\nTesting SinkData\n");
 184
 185         data_in = talloc_size(mem_ctx, len);
 186         for (i=0;i<len;i++) {
 187                 data_in[i] = i+1;
 188         }
 189
 190         r.in.len = len;
 191         r.in.data = data_in;
 192
 193         status = dcerpc_echo_SinkData(p, mem_ctx, &r);
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 printf("SinkData(%d) failed - %s\n", len, nt_errstr(status));
 196                 return False;
 197         }
 198
 199         printf("sunk %d bytes\n", len);
 200
 201         return True;
 202 }
 203
 204
 205 /*
 206   test the testcall interface
 207 */
 208 static BOOL test_testcall(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 209 {
 210         NTSTATUS status;
 211         struct echo_TestCall r;
 212
 213         r.in.s1 = "input string";
 214
 215         printf("\nTesting TestCall\n");
 216         status = dcerpc_echo_TestCall(p, mem_ctx, &r);
 217         if (!NT_STATUS_IS_OK(status)) {
 218                 printf("TestCall failed - %s\n", nt_errstr(status));
 219                 return False;
 220         }
 221
 222         return True;
 223 }
 224
 225 /*
 226   test the testcall interface
 227 */
 228 static BOOL test_testcall2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 229 {
 230         NTSTATUS status;
 231         struct echo_TestCall2 r;
 232         int i;
 233         BOOL ret = True;
 234
 235         for (i=1;i<=7;i++) {
 236                 r.in.level = i;
 237                 r.out.info = talloc(mem_ctx, union echo_Info);
 238
 239                 printf("\nTesting TestCall2 level %d\n", i);
 240                 status = dcerpc_echo_TestCall2(p, mem_ctx, &r);
 241                 if (!NT_STATUS_IS_OK(status)) {
 242                         printf("TestCall2 failed - %s\n", nt_errstr(status));
 243                         ret = False;
 244                 }
 245         }
 246
 247         return ret;
 248 }
 249
 250 /*
 251   test the TestSleep interface
 252 */
 253 static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 254 {
 255         int i;
 256         NTSTATUS status;
 257 #define ASYNC_COUNT 3
 258         struct rpc_request *req[ASYNC_COUNT];
 259         struct echo_TestSleep r[ASYNC_COUNT];
 260         BOOL done[ASYNC_COUNT];
 261         struct timeval snd[ASYNC_COUNT];
 262         struct timeval rcv[ASYNC_COUNT];
 263         struct timeval diff[ASYNC_COUNT];
 264         struct event_context *ctx;
 265         int total_done = 0;
 266         BOOL ret = True;
 267
 268         if (lp_parm_bool(-1, "torture", "quick", False)) {
 269                 printf("TestSleep disabled - use \"torture:quick=no\" to enable\n");
 270                 return True;
 271         }
 272         printf("Testing TestSleep - use \"torture:quick=no\" to disable\n");
 273
 274         for (i=0;i<ASYNC_COUNT;i++) {
 275                 done[i]         = False;
 276                 snd[i]          = timeval_current();
 277                 rcv[i]          = timeval_zero();
 278                 r[i].in.seconds = ASYNC_COUNT-i;
 279                 req[i] = dcerpc_echo_TestSleep_send(p, mem_ctx, &r[i]);
 280                 if (!req[i]) {
 281                         printf("Failed to send async sleep request\n");
 282                         return False;
 283                 }
 284         }
 285
 286         ctx = dcerpc_event_context(p);
 287         while (total_done < ASYNC_COUNT) {
 288                 if (event_loop_once(ctx) != 0) {
 289                         return False;
 290                 }
 291                 for (i=0;i<ASYNC_COUNT;i++) {
 292                         if (done[i] == False && req[i]->state == RPC_REQUEST_DONE) {
 293                                 total_done++;
 294                                 done[i] = True;
 295                                 rcv[i]  = timeval_current();
 296                                 diff[i] = timeval_until(&snd[i], &rcv[i]);
 297                                 status  = dcerpc_ndr_request_recv(req[i]);
 298                                 if (!NT_STATUS_IS_OK(status)) {
 299                                         printf("TestSleep(%d) failed - %s\n",
 300                                                i, nt_errstr(status));
 301                                         ret = False;
 302                                 } else if (r[i].out.result != r[i].in.seconds) {
 303                                         printf("Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)\n",
 304                                                 r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec);
 305                                         ret = False;
 306                                 } else {
 307                                         if (r[i].out.result > diff[i].tv_sec) {
 308                                                 printf("Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)\n",
 309                                                         r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
 310                                         } else if (r[i].out.result+1 == diff[i].tv_sec) {
 311                                                 printf("Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
 312                                                         r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
 313                                         } else if (r[i].out.result == diff[i].tv_sec) {
 314                                                 printf("Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
 315                                                         r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
 316                                         } else {
 317                                                 printf("(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
 318                                                         r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
 319                                                 /* TODO: let the test fail here, when we support async rpc on ncacn_np
 320                                                 ret = False;*/
 321                                         }
 322                                 }
 323                         }
 324                 }
 325         }
 326
 327         return ret;
 328 }
 329
 330 /*
 331   test enum handling
 332 */
 333 static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 334 {
 335         NTSTATUS status;
 336         struct echo_TestEnum r;
 337         BOOL ret = True;
 338         enum echo_Enum1 v = ECHO_ENUM1;
 339         struct echo_Enum2 e2;
 340         union echo_Enum3 e3;
 341
 342         r.in.foo1 = &v;
 343         r.in.foo2 = &e2;
 344         r.in.foo3 = &e3;
 345         r.out.foo1 = &v;
 346         r.out.foo2 = &e2;
 347         r.out.foo3 = &e3;
 348
 349         e2.e1 = 76;
 350         e2.e2 = ECHO_ENUM1_32;
 351         e3.e1 = ECHO_ENUM2;
 352
 353         printf("\nTesting TestEnum\n");
 354         status = dcerpc_echo_TestEnum(p, mem_ctx, &r);
 355         if (!NT_STATUS_IS_OK(status)) {
 356                 printf("TestEnum failed - %s\n", nt_errstr(status));
 357                 ret = False;
 358         }
 359
 360         return ret;
 361 }
 362
 363 /*
 364   test surrounding conformant array handling
 365 */
 366 static BOOL test_surrounding(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 367 {
 368         NTSTATUS status;
 369         struct echo_TestSurrounding r;
 370         BOOL ret = True;
 371
 372         ZERO_STRUCT(r);
 373         r.in.data = talloc(mem_ctx, struct echo_Surrounding);
 374
 375         r.in.data->x = 20;
 376         r.in.data->surrounding = talloc_zero_array(mem_ctx, uint16_t, r.in.data->x);
 377
 378         r.out.data = talloc(mem_ctx, struct echo_Surrounding);
 379
 380         printf("\nTesting TestSurrounding\n");
 381         status = dcerpc_echo_TestSurrounding(p, mem_ctx, &r);
 382         if (!NT_STATUS_IS_OK(status)) {
 383                 printf("TestSurrounding failed - %s\n", nt_errstr(status));
 384                 return False;
 385         }
 386
 387         if (r.out.data->x != 2 * r.in.data->x) {
 388                 printf("TestSurrounding did not make the array twice as large\n");
 389                 ret = False;
 390         }
 391
 392         return ret;
 393 }
 394
 395 /*
 396   test multiple levels of pointers
 397 */
 398 static BOOL test_doublepointer(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 399 {
 400         NTSTATUS status;
 401         struct echo_TestDoublePointer r;
 402         BOOL ret = True;
 403         uint16_t value = 12;
 404         uint16_t *pvalue = &value;
 405         uint16_t **ppvalue = &pvalue;
 406
 407         ZERO_STRUCT(r);
 408         r.in.data = &ppvalue;
 409
 410         printf("\nTesting TestDoublePointer\n");
 411         status = dcerpc_echo_TestDoublePointer(p, mem_ctx, &r);
 412         if (!NT_STATUS_IS_OK(status)) {
 413                 printf("TestDoublePointer failed - %s\n", nt_errstr(status));
 414                 ret = False;
 415         }
 416
 417         if (value != r.out.result) {
 418                 printf("TestDoublePointer did not return original value (%d != %d)\n", value, r.out.result);
 419                 ret = False;
 420         }
 421
 422         return ret;
 423 }
 424
 425
 426 /*
 427   test request timeouts
 428 */
 429 static BOOL test_timeout(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 430 {
 431         NTSTATUS status;
 432         struct rpc_request *req;
 433         struct echo_TestSleep r;
 434         int timeout_saved = p->request_timeout;
 435
 436         if (lp_parm_bool(-1, "torture", "quick", False)) {
 437                 printf("timeout testing disabled - use \"torture:quick=no\" to enable\n");
 438                 return True;
 439         }
 440
 441         printf("testing request timeouts\n");
 442         r.in.seconds = 2;
 443         p->request_timeout = 1;
 444
 445         req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
 446         if (!req) {
 447                 printf("Failed to send async sleep request\n");
 448                 goto failed;
 449         }
 450
 451         status  = dcerpc_ndr_request_recv(req);
 452         if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
 453                 printf("request should have timed out - %s\n", nt_errstr(status));
 454                 goto failed;
 455         }
 456
 457         printf("testing request destruction\n");
 458         req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
 459         if (!req) {
 460                 printf("Failed to send async sleep request\n");
 461                 goto failed;
 462         }
 463         talloc_free(req);
 464
 465         req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r);
 466         if (!req) {
 467                 printf("Failed to send async sleep request\n");
 468                 goto failed;
 469         }
 470         status  = dcerpc_ndr_request_recv(req);
 471         if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
 472                 printf("request should have timed out - %s\n", nt_errstr(status));
 473                 goto failed;
 474         }
 475
 476         p->request_timeout = timeout_saved;
 477         return test_addone(p, mem_ctx);
 478
 479 failed:
 480         p->request_timeout = timeout_saved;
 481         return False;
 482 }
 483
 484
 485 BOOL torture_rpc_echo(void)
 486 {
 487         NTSTATUS status;
 488         struct dcerpc_pipe *p;
 489         TALLOC_CTX *mem_ctx;
 490         BOOL ret = True;
 491
 492         mem_ctx = talloc_init("torture_rpc_echo");
 493
 494         status = torture_rpc_connection(mem_ctx,
 495                                         &p,
 496                                         &dcerpc_table_rpcecho);
 497         if (!NT_STATUS_IS_OK(status)) {
 498                 return False;
 499         }
 500
 501         ret &= test_addone(p, mem_ctx);
 502         ret &= test_sinkdata(p, mem_ctx);
 503         ret &= test_echodata(p, mem_ctx);
 504         ret &= test_sourcedata(p, mem_ctx);
 505         ret &= test_testcall(p, mem_ctx);
 506         ret &= test_testcall2(p, mem_ctx);
 507         ret &= test_enum(p, mem_ctx);
 508         ret &= test_surrounding(p, mem_ctx);
 509         ret &= test_doublepointer(p, mem_ctx);
 510         ret &= test_sleep(p, mem_ctx);
 511         ret &= test_timeout(p, mem_ctx);
 512
 513         printf("\n");
 514
 515         talloc_free(mem_ctx);
 516
 517         return ret;
 518 }