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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24
  25 /*
  26   test the AddOne interface
  27 */
  28 static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  29 {
  30         int i;
  31         NTSTATUS status;
  32
  33         printf("\nTesting AddOne\n");
  34
  35         for (i=0;i<10;i++) {
  36                 int n;
  37                 status = dcerpc_rpcecho_addone(p, i, &n);
  38                 if (!NT_STATUS_IS_OK(status)) {
  39                         printf("AddOne(%d) failed - %s\n", i, nt_errstr(status));
  40                         return False;
  41                 }
  42                 printf("%d + 1 = %d\n", i, n);
  43         }
  44
  45         return True;
  46 }
  47
  48 /*
  49   test the EchoData interface
  50 */
  51 static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  52 {
  53         int i;
  54         NTSTATUS status;
  55         char *data_in, *data_out;
  56         int len = 17;
  57         int len_out;
  58
  59         printf("\nTesting EchoData\n");
  60
  61         data_in = talloc(mem_ctx, len);
  62         for (i=0;i<len;i++) {
  63                 data_in[i] = i+1;
  64         }
  65
  66         status = dcerpc_rpcecho_echodata(p, mem_ctx,
  67                                          len,
  68                                          data_in,
  69                                          &len_out,
  70                                          &data_out);
  71         if (!NT_STATUS_IS_OK(status)) {
  72                 printf("EchoData(%d) failed - %s\n", len, nt_errstr(status));
  73                 return False;
  74         }
  75         printf("EchoData(%d) returned %d bytes\n", len, len_out);
  76
  77         if (memcmp(data_in, data_out, len) != 0) {
  78                 printf("Bad data returned!\n");
  79                 return False;
  80         }
  81
  82
  83         return True;
  84 }
  85
  86
  87 /*
  88   test the SourceData interface
  89 */
  90 static BOOL test_sourcedata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  91 {
  92         int i;
  93         NTSTATUS status;
  94         char *data_out;
  95         int len = 200000;
  96         int len_out;
  97
  98         printf("\nTesting SourceData\n");
  99
 100         status = dcerpc_rpcecho_sourcedata(p, mem_ctx,
 101                                            len,
 102                                            &len_out,
 103                                            &data_out);
 104         if (!NT_STATUS_IS_OK(status)) {
 105                 printf("SourceData(%d) failed - %s\n", len, nt_errstr(status));
 106                 return False;
 107         }
 108         printf("SourceData(%d) returned %d bytes\n", len, len_out);
 109
 110         for (i=0;i<len;i++) {
 111                 unsigned char *v = (unsigned char *)data_out;
 112                 if (v[i] != (i & 0xFF)) {
 113                         printf("bad data 0x%x at %d\n", data_out[i], i);
 114                         return False;
 115                 }
 116         }
 117
 118         return True;
 119 }
 120
 121 /*
 122   test the SinkData interface
 123 */
 124 static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 125 {
 126         int i;
 127         NTSTATUS status;
 128         char *data_in;
 129         int len = 200000;
 130
 131         printf("\nTesting SinkData\n");
 132
 133         data_in = talloc(mem_ctx, len);
 134         for (i=0;i<len;i++) {
 135                 data_in[i] = i+1;
 136         }
 137
 138         status = dcerpc_rpcecho_sinkdata(p, mem_ctx,
 139                                          len,
 140                                          data_in);
 141         if (!NT_STATUS_IS_OK(status)) {
 142                 printf("SinkData(%d) failed - %s\n", len, nt_errstr(status));
 143                 return False;
 144         }
 145
 146         return True;
 147 }
 148
 149 BOOL torture_rpc_echo(int dummy)
 150 {
 151         NTSTATUS status;
 152         struct dcerpc_pipe *p;
 153         TALLOC_CTX *mem_ctx;
 154         BOOL ret = True;
 155
 156         mem_ctx = talloc_init("torture_rpc_echo");
 157
 158         status = torture_rpc_connection(&p, "rpcecho");
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 return False;
 161         }
 162
 163         if (!test_addone(p, mem_ctx)) {
 164                 ret = False;
 165         }
 166
 167         if (!test_echodata(p, mem_ctx)) {
 168                 ret = False;
 169         }
 170
 171         if (!test_sourcedata(p, mem_ctx)) {
 172                 ret = False;
 173         }
 174
 175         if (!test_sinkdata(p, mem_ctx)) {
 176                 ret = False;
 177         }
 178
 179         printf("\n");
 180
 181         torture_rpc_close(p);
 182         return ret;
 183 }