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,
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"
#include "lib/socket/socket.h"
#include "libcli/resolve/resolve.h"
#include "system/network.h"
-#include "netif/netif.h"
+#include "lib/socket/netif.h"
#include "torture/torture.h"
+#include "torture/nbt/proto.h"
+#include "param/param.h"
struct wins_state {
int num_names;
- BOOL *registered;
+ bool *registered;
int pass_count;
int fail_count;
const char *wins_server;
+ uint16_t wins_port;
const char *my_ip;
uint32_t ttl;
};
struct wins_state *state;
};
-struct nbt_name generate_name(TALLOC_CTX *mem_ctx, int idx)
+static struct nbt_name generate_name(TALLOC_CTX *tctx, int idx)
{
struct nbt_name name;
- name.name = talloc_asprintf(mem_ctx, "WINSBench%6u", idx);
+ name.name = talloc_asprintf(tctx, "WINSBench%6u", idx);
name.type = 0x4;
name.scope = NULL;
return name;
static void register_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_register io;
NTSTATUS status;
state->fail_count++;
} else {
state->pass_count++;
- state->registered[istate->idx] = True;
+ state->registered[istate->idx] = true;
}
talloc_free(istate);
}
io.in.name = generate_name(tmp_ctx, idx);
io.in.dest_addr = state->wins_server;
+ io.in.dest_port = state->wins_port;
io.in.address = state->my_ip;
io.in.nb_flags = NBT_NODE_H;
- io.in.register_demand = False;
- io.in.broadcast = False;
- io.in.multi_homed = False;
+ io.in.register_demand = false;
+ io.in.broadcast = false;
+ io.in.multi_homed = false;
io.in.ttl = state->ttl;
io.in.timeout = 2;
io.in.retries = 1;
req = nbt_name_register_send(nbtsock, &io);
req->async.fn = register_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
static void release_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_release io;
NTSTATUS status;
state->fail_count++;
} else {
state->pass_count++;
- state->registered[istate->idx] = False;
+ state->registered[istate->idx] = false;
}
talloc_free(istate);
}
istate->state = state;
io.in.name = generate_name(tmp_ctx, idx);
+ io.in.dest_port = state->wins_port;
io.in.dest_addr = state->wins_server;
io.in.address = state->my_ip;
io.in.nb_flags = NBT_NODE_H;
- io.in.broadcast = False;
+ io.in.broadcast = false;
io.in.timeout = 2;
io.in.retries = 1;
req = nbt_name_release_send(nbtsock, &io);
req->async.fn = release_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
static void query_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_query io;
NTSTATUS status;
io.in.name = generate_name(tmp_ctx, idx);
io.in.dest_addr = state->wins_server;
- io.in.broadcast = False;
- io.in.wins_lookup = True;
+ io.in.dest_port = state->wins_port;
+ io.in.broadcast = false;
+ io.in.wins_lookup = true;
io.in.timeout = 2;
io.in.retries = 1;
req = nbt_name_query_send(nbtsock, &io);
req->async.fn = query_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
/*
benchmark simple name queries
*/
-static BOOL bench_wins(TALLOC_CTX *mem_ctx, struct nbt_name *name, const char *address)
+static bool bench_wins(struct torture_context *tctx)
{
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(mem_ctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, tctx->ev);
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", 5);
struct wins_state *state;
extern int torture_entries;
struct socket_address *my_ip;
+ struct nbt_name name;
+ const char *address;
+ struct interface *ifaces;
+
+ if (!torture_nbt_get_name(tctx, &name, &address))
+ return false;
state = talloc_zero(nbtsock, struct wins_state);
state->num_names = torture_entries;
- state->registered = talloc_zero_array(state, BOOL, state->num_names);
+ state->registered = talloc_zero_array(state, bool, state->num_names);
state->wins_server = address;
- state->my_ip = talloc_strdup(mem_ctx, iface_best_ip(address));
+ state->wins_port = lpcfg_nbt_port(tctx->lp_ctx);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
+ state->my_ip = talloc_strdup(tctx, iface_best_ip(ifaces, address));
state->ttl = timelimit;
my_ip = socket_address_from_strings(nbtsock, nbtsock->sock->backend_name,
socket_listen(nbtsock->sock, my_ip, 0, 0);
- printf("Running for %d seconds\n", timelimit);
+ torture_comment(tctx, "Running for %d seconds\n", timelimit);
while (timeval_elapsed(&tv) < timelimit) {
while (num_sent - (state->pass_count+state->fail_count) < 10) {
generate_request(nbtsock, state, num_sent % state->num_names);
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)) {
+ torture_comment(tctx, "%.1f queries per second (%d failures) \r",
+ state->pass_count / timeval_elapsed(&tv),
+ state->fail_count);
+ fflush(stdout);
+ }
}
}
event_loop_once(nbtsock->event_ctx);
}
- printf("%.1f queries per second (%d failures) \n",
+ torture_comment(tctx, "%.1f queries per second (%d failures) \n",
state->pass_count / timeval_elapsed(&tv),
state->fail_count);
benchmark how fast a WINS server can respond to a mixture of
registration/refresh/release and name query requests
*/
-BOOL torture_bench_wins(struct torture_context *torture)
+struct torture_suite *torture_bench_wins(TALLOC_CTX *mem_ctx)
{
- const char *address;
- struct nbt_name name;
- TALLOC_CTX *mem_ctx = talloc_new(NULL);
- NTSTATUS status;
- BOOL ret = True;
-
- make_nbt_name_server(&name, lp_parm_string(-1, "torture", "host"));
-
- /* do an initial name resolution to find its IP */
- status = resolve_name(&name, mem_ctx, &address, event_context_find(mem_ctx));
- if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to resolve %s - %s\n",
- name.name, nt_errstr(status));
- talloc_free(mem_ctx);
- return False;
- }
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "bench-wins");
- ret &= bench_wins(mem_ctx, &name, address);
+ torture_suite_add_simple_test(suite, "wins", bench_wins);
- talloc_free(mem_ctx);
-
- return ret;
+ return suite;
}
git.samba.org / metze / samba / wip.git / blobdiff