Merge branch 'master' of ssh://git.samba.org/data/git/samba

[kai/samba.git] / source4 / torture / ldap / cldapbench.c

diff --git a/source4/torture/ldap/cldapbench.c b/source4/torture/ldap/cldapbench.c
index 99ab69cee409df2f0e1408e5265e2052d8bd6b44..1fcfe5a050802e0260d8301dd1a674773ea0f0bc 100644 (file)
--- a/source4/torture/ldap/cldapbench.c
+++ b/source4/torture/ldap/cldapbench.c
@@ -7,7 +7,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -16,8 +16,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
@@ -25,6 +24,7 @@
 #include "libcli/cldap/cldap.h"
 #include "libcli/resolve/resolve.h"
 #include "torture/torture.h"
+#include "param/param.h"
 
 struct bench_state {
        int pass_count, fail_count;
@@ -33,7 +33,7 @@ struct bench_state {
 static void request_handler(struct cldap_request *req)
 {
        struct cldap_netlogon io;
-       struct bench_state *state = talloc_get_type(req->async.private, struct bench_state);
+       struct bench_state *state = talloc_get_type(req->async.private_data, struct bench_state);
        NTSTATUS status;
        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
        io.in.version = 6;
@@ -49,20 +49,23 @@ static void request_handler(struct cldap_request *req)
 /*
   benchmark cldap calls
 */
-static BOOL bench_cldap(TALLOC_CTX *mem_ctx, const char *address)
+static bool bench_cldap(struct torture_context *tctx, const char *address)
 {
-       struct cldap_socket *cldap = cldap_socket_init(mem_ctx, NULL);
+       struct cldap_socket *cldap;
        int num_sent=0;
        struct timeval tv = timeval_current();
-       BOOL ret = True;
-       int timelimit = lp_parm_int(-1, "torture", "timelimit", 10);
+       bool ret = true;
+       int timelimit = torture_setting_int(tctx, "timelimit", 10);
        struct cldap_netlogon search;
        struct bench_state *state;
 
-       state = talloc_zero(mem_ctx, struct bench_state);
+       cldap = cldap_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+
+       state = talloc_zero(tctx, struct bench_state);
 
        ZERO_STRUCT(search);
        search.in.dest_address = address;
+       search.in.dest_port     = lp_cldap_port(tctx->lp_ctx);
        search.in.acct_control = -1;
        search.in.version = 6;
 
@@ -72,13 +75,16 @@ static BOOL bench_cldap(TALLOC_CTX *mem_ctx, const char *address)
                        struct cldap_request *req;
                        req = cldap_netlogon_send(cldap, &search);
 
-                       req->async.private = state;
+                       req->async.private_data = state;
                        req->async.fn = request_handler;
                        num_sent++;
                        if (num_sent % 50 == 0) {
-                               printf("%.1f queries per second (%d failures)  \r", 
-                                      state->pass_count / timeval_elapsed(&tv),
-                                      state->fail_count);
+                               if (torture_setting_bool(tctx, "progress", true)) {
+                                       printf("%.1f queries per second (%d failures)  \r", 
+                                              state->pass_count / timeval_elapsed(&tv),
+                                              state->fail_count);
+                                       fflush(stdout);
+                               }
                        }
                }
 
@@ -102,28 +108,24 @@ static BOOL bench_cldap(TALLOC_CTX *mem_ctx, const char *address)
   benchmark how fast a CLDAP server can respond to a series of parallel
   requests 
 */
-BOOL torture_bench_cldap(struct torture_context *torture)
+bool torture_bench_cldap(struct torture_context *torture)
 {
        const char *address;
        struct nbt_name name;
-       TALLOC_CTX *mem_ctx = talloc_new(NULL);
        NTSTATUS status;
-       BOOL ret = True;
+       bool ret = true;
        
        make_nbt_name_server(&name, torture_setting_string(torture, "host", NULL));
 
        /* do an initial name resolution to find its IP */
-       status = resolve_name(&name, mem_ctx, &address, event_context_find(mem_ctx));
+       status = resolve_name(lp_resolve_context(torture->lp_ctx), &name, torture, &address, torture->ev);
        if (!NT_STATUS_IS_OK(status)) {
                printf("Failed to resolve %s - %s\n",
                       name.name, nt_errstr(status));
-               talloc_free(mem_ctx);
-               return False;
+               return false;
        }
 
-       ret &= bench_cldap(mem_ctx, address);
-
-       talloc_free(mem_ctx);
+       ret &= bench_cldap(torture, address);
 
        return ret;
 }