s4-srvsvc: merge srvsvc_NetShareEnumAll from s3 idl.
[samba.git] / source4 / torture / rpc / bench.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    simple RPC benchmark
5
6    Copyright (C) Andrew Tridgell 2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "torture/torture.h"
24 #include "librpc/gen_ndr/ndr_srvsvc_c.h"
25 #include "torture/rpc/rpc.h"
26
27 /**************************/
28 /* srvsvc_NetShare        */
29 /**************************/
30 static bool test_NetShareEnumAll(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
31 {
32         NTSTATUS status;
33         struct srvsvc_NetShareEnumAll r;
34         struct srvsvc_NetShareInfoCtr info_ctr;
35         struct srvsvc_NetShareCtr0 c0;
36         struct srvsvc_NetShareCtr1 c1;
37         struct srvsvc_NetShareCtr2 c2;
38         struct srvsvc_NetShareCtr501 c501;
39         struct srvsvc_NetShareCtr502 c502;
40         uint32_t totalentries = 0;
41         uint32_t levels[] = {0, 1, 2, 501, 502};
42         int i;
43         bool ret = true;
44         uint32_t resume_handle;
45
46         ZERO_STRUCT(info_ctr);
47
48         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
49         r.in.info_ctr = &info_ctr;
50         r.in.max_buffer = (uint32_t)-1;
51         r.in.resume_handle = &resume_handle;
52         r.out.resume_handle = &resume_handle;
53         r.out.totalentries = &totalentries;
54         r.out.info_ctr = &info_ctr;
55
56         for (i=0;i<ARRAY_SIZE(levels);i++) {
57                 resume_handle = 0;
58                 info_ctr.level = levels[i];
59
60                 switch (info_ctr.level) {
61                 case 0:
62                         ZERO_STRUCT(c0);
63                         info_ctr.ctr.ctr0 = &c0;
64                         break;
65                 case 1:
66                         ZERO_STRUCT(c1);
67                         info_ctr.ctr.ctr1 = &c1;
68                         break;
69                 case 2:
70                         ZERO_STRUCT(c2);
71                         info_ctr.ctr.ctr2 = &c2;
72                         break;
73                 case 501:
74                         ZERO_STRUCT(c501);
75                         info_ctr.ctr.ctr501 = &c501;
76                         break;
77                 case 502:
78                         ZERO_STRUCT(c502);
79                         info_ctr.ctr.ctr502 = &c502;
80                         break;
81                 }
82
83                 status = dcerpc_srvsvc_NetShareEnumAll(p, mem_ctx, &r);
84                 if (!NT_STATUS_IS_OK(status)) {
85                         printf("NetShareEnumAll level %u failed - %s\n", info_ctr.level, nt_errstr(status));
86                         ret = false;
87                         continue;
88                 }
89                 if (!W_ERROR_IS_OK(r.out.result)) {
90                         printf("NetShareEnumAll level %u failed - %s\n", info_ctr.level, win_errstr(r.out.result));
91                         continue;
92                 }
93         }
94
95         return ret;
96 }
97
98 /*
99   benchmark srvsvc netshareenumall queries
100 */
101 static bool bench_NetShareEnumAll(struct torture_context *tctx, struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
102 {
103         struct timeval tv = timeval_current();
104         bool ret = true;
105         int timelimit = torture_setting_int(tctx, "timelimit", 10);
106         int count=0;
107
108         printf("Running for %d seconds\n", timelimit);
109         while (timeval_elapsed(&tv) < timelimit) {
110                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
111                 if (!test_NetShareEnumAll(p, tmp_ctx)) break;
112                 talloc_free(tmp_ctx);
113                 count++;
114                 if (count % 50 == 0) {
115                         if (torture_setting_bool(tctx, "progress", true)) {
116                                 printf("%.1f queries per second  \r", 
117                                        count / timeval_elapsed(&tv));
118                         }
119                 }
120         }
121
122         printf("%.1f queries per second  \n", count / timeval_elapsed(&tv));
123
124         return ret;
125 }
126
127
128 bool torture_bench_rpc(struct torture_context *torture)
129 {
130         NTSTATUS status;
131         struct dcerpc_pipe *p;
132         TALLOC_CTX *mem_ctx;
133         bool ret = true;
134
135         mem_ctx = talloc_init("torture_rpc_srvsvc");
136
137         status = torture_rpc_connection(torture, 
138                                         &p,
139                                         &ndr_table_srvsvc);
140         if (!NT_STATUS_IS_OK(status)) {
141                 talloc_free(mem_ctx);
142                 return false;
143         }
144
145         if (!bench_NetShareEnumAll(torture, p, mem_ctx)) {
146                 ret = false;
147         }
148
149         talloc_free(mem_ctx);
150
151         return ret;
152 }