*
* 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 <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#include <malloc.h>
+#include "replace.h"
+#include "system/network.h"
+#include "system/time.h"
+#include "system/wait.h"
+
#include <assert.h>
-#include <unistd.h>
-#include <signal.h>
-#include <sys/time.h>
-#include <time.h>
+#include <talloc.h>
+#include <tevent.h>
+
+#include "lib/util/time.h"
+#include "lib/util/debug.h"
+
+#include "common/logging.h"
-#include "includes.h"
-#include "lib/events/events.h"
#include "ib/ibwrapper.h"
struct ibwtest_ctx {
TESTOP_SEND_RND = 3
};
-int ibwtest_connect_everybody(struct ibwtest_ctx *tcx)
+static int ibwtest_connect_everybody(struct ibwtest_ctx *tcx)
{
struct ibw_conn *conn;
struct ibwtest_conn *tconn = talloc_zero(tcx, struct ibwtest_conn);
return -1;
}
}
- DEBUG(10, ("sent %d connect request...\n", tcx->naddrs));
+ DEBUG(DEBUG_DEBUG, ("sent %d connect request...\n", tcx->naddrs));
return 0;
}
-int ibwtest_send_id(struct ibw_conn *conn)
+static int ibwtest_send_id(struct ibw_conn *conn)
{
struct ibwtest_ctx *tcx = talloc_get_type(conn->ctx->ctx_userdata, struct ibwtest_ctx);
char *buf;
void *key;
uint32_t len;
- DEBUG(10, ("ibwtest_send_id\n"));
+ DEBUG(DEBUG_DEBUG, ("ibwtest_send_id\n"));
len = sizeof(uint32_t)+strlen(tcx->id)+2;
if (ibw_alloc_send_buf(conn, (void **)&buf, &key, len)) {
- DEBUG(0, ("send_id: ibw_alloc_send_buf failed\n"));
+ DEBUG(DEBUG_ERR, ("send_id: ibw_alloc_send_buf failed\n"));
return -1;
}
strcpy(buf+sizeof(uint32_t)+1, tcx->id);
if (ibw_send(conn, buf, key, len)) {
- DEBUG(0, ("send_id: ibw_send error\n"));
+ DEBUG(DEBUG_ERR, ("send_id: ibw_send error\n"));
return -1;
}
tcx->nsent++;
return 0;
}
-int ibwtest_send_test_msg(struct ibwtest_ctx *tcx, struct ibw_conn *conn, const char *msg)
+static int ibwtest_send_test_msg(struct ibwtest_ctx *tcx, struct ibw_conn *conn, const char *msg)
{
char *buf, *p;
void *key;
strcpy(p, msg);
if (ibw_send(conn, buf, key, len)) {
- DEBUG(0, ("send_test_msg: ibw_send error\n"));
+ DEBUG(DEBUG_ERR, ("send_test_msg: ibw_send error\n"));
return -1;
}
tcx->nsent++;
return 0;
}
-unsigned char ibwtest_fill_random(unsigned char *buf, uint32_t size)
+static unsigned char ibwtest_fill_random(unsigned char *buf, uint32_t size)
{
uint32_t i = size;
unsigned char sum = 0;
return sum;
}
-unsigned char ibwtest_get_sum(unsigned char *buf, uint32_t size)
+static unsigned char ibwtest_get_sum(unsigned char *buf, uint32_t size)
{
uint32_t i = size;
unsigned char sum = 0;
return sum;
}
-int ibwtest_do_varsize_scenario_conn_size(struct ibwtest_ctx *tcx, struct ibw_conn *conn, uint32_t size)
+static int ibwtest_do_varsize_scenario_conn_size(struct ibwtest_ctx *tcx, struct ibw_conn *conn, uint32_t size)
{
unsigned char *buf;
void *key;
len = sizeof(uint32_t) + 1 + size + 1;
if (ibw_alloc_send_buf(conn, (void **)&buf, &key, len)) {
- DEBUG(0, ("varsize/ibw_alloc_send_buf failed\n"));
+ DEBUG(DEBUG_ERR, ("varsize/ibw_alloc_send_buf failed\n"));
return -1;
}
*((uint32_t *)buf) = len;
sum = ibwtest_fill_random(buf + sizeof(uint32_t) + 1, size);
buf[sizeof(uint32_t) + 1 + size] = sum;
if (ibw_send(conn, buf, key, len)) {
- DEBUG(0, ("varsize/ibw_send failed\n"));
+ DEBUG(DEBUG_ERR, ("varsize/ibw_send failed\n"));
return -1;
}
tcx->nsent++;
return 0;
}
-int ibwtest_do_varsize_scenario_conn(struct ibwtest_ctx *tcx, struct ibw_conn *conn)
+static int ibwtest_do_varsize_scenario_conn(struct ibwtest_ctx *tcx, struct ibw_conn *conn)
{
uint32_t size;
int i;
}
}*/
-int ibwtest_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
+static int ibwtest_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
{
struct ibwtest_ctx *tcx = NULL; /* userdata */
struct ibwtest_conn *tconn = NULL; /* userdata */
switch(ctx->state) {
case IBWS_INIT:
- DEBUG(10, ("test IBWS_INIT\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWS_INIT\n"));
break;
case IBWS_READY:
- DEBUG(10, ("test IBWS_READY\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWS_READY\n"));
break;
case IBWS_CONNECT_REQUEST:
- DEBUG(10, ("test IBWS_CONNECT_REQUEST\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWS_CONNECT_REQUEST\n"));
tconn = talloc_zero(conn, struct ibwtest_conn);
if (ibw_accept(ctx, conn, tconn)) {
- DEBUG(0, ("error accepting the connect request\n"));
+ DEBUG(DEBUG_ERR, ("error accepting the connect request\n"));
}
break;
case IBWS_STOPPED:
- DEBUG(10, ("test IBWS_STOPPED\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWS_STOPPED\n"));
tcx->kill_me = 1; /* main loop can exit */
break;
case IBWS_ERROR:
- DEBUG(10, ("test IBWS_ERROR\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWS_ERROR\n"));
ibw_stop(tcx->ibwctx);
break;
default:
tconn = talloc_get_type(conn->conn_userdata, struct ibwtest_conn);
switch(conn->state) {
case IBWC_INIT:
- DEBUG(10, ("test IBWC_INIT\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWC_INIT\n"));
break;
case IBWC_CONNECTED:
if (gettimeofday(&tcx->start_time, NULL)) {
- DEBUG(0, ("gettimeofday error %d", errno));
+ DEBUG(DEBUG_ERR, ("gettimeofday error %d", errno));
return -1;
}
ibwtest_send_id(conn);
break;
case IBWC_DISCONNECTED:
- DEBUG(10, ("test IBWC_DISCONNECTED\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWC_DISCONNECTED\n"));
talloc_free(conn);
break;
case IBWC_ERROR:
- DEBUG(10, ("test IBWC_ERROR\n"));
+ DEBUG(DEBUG_DEBUG, ("test IBWC_ERROR %s\n", ibw_getLastError()));
break;
default:
assert(0);
return 0;
}
-int ibwtest_receive_handler(struct ibw_conn *conn, void *buf, int n)
+static int ibwtest_receive_handler(struct ibw_conn *conn, void *buf, int n)
{
struct ibwtest_conn *tconn;
enum testopcode op;
tconn->id = talloc_strdup(tconn, ((char *)buf)+sizeof(uint32_t)+1);
}
if (op==TESTOP_SEND_ID || op==TESTOP_SEND_TEXT) {
- DEBUG(11, ("[%d]msg from %s: \"%s\"(%d)\n", op,
+ DEBUG(DEBUG_DEBUG, ("[%d]msg from %s: \"%s\"(%d)\n", op,
tconn->id ? tconn->id : "NULL", ((char *)buf)+sizeof(uint32_t)+1, n));
}
unsigned char sum;
sum = ibwtest_get_sum((unsigned char *)buf + sizeof(uint32_t) + 1,
n - sizeof(uint32_t) - 2);
- DEBUG(11, ("[%d]msg varsize %u/sum %u from %s\n",
+ DEBUG(DEBUG_DEBUG, ("[%d]msg varsize %u/sum %u from %s\n",
op,
- n - sizeof(uint32_t) - 2,
+ (uint32_t)(n - sizeof(uint32_t) - 2),
(uint32_t)sum,
tconn->id ? tconn->id : "NULL"));
if (sum!=((unsigned char *)buf)[n-1]) {
- DEBUG(0, ("ERROR: checksum mismatch %u!=%u\n",
+ DEBUG(DEBUG_ERR, ("ERROR: checksum mismatch %u!=%u\n",
(uint32_t)sum, (uint32_t)((unsigned char *)buf)[n-1]));
ibw_stop(tcx->ibwctx);
goto error;
return -1;
}
-void ibwtest_timeout_handler(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private_data)
+static void ibwtest_timeout_handler(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t, void *private_data)
{
struct ibwtest_ctx *tcx = talloc_get_type(private_data, struct ibwtest_ctx);
int rc;
static struct ibwtest_ctx *testctx = NULL;
-void ibwtest_sigint_handler(int sig)
+static void ibwtest_sigint_handler(int sig)
{
- DEBUG(0, ("got SIGINT\n"));
+ DEBUG(DEBUG_ERR, ("got SIGINT\n"));
if (testctx) {
if (testctx->ibwctx->state==IBWS_READY ||
testctx->ibwctx->state==IBWS_CONNECT_REQUEST ||
testctx->ibwctx->state==IBWS_ERROR)
{
if (testctx->stopping) {
- DEBUG(10, ("forcing exit...\n"));
+ DEBUG(DEBUG_DEBUG, ("forcing exit...\n"));
testctx->kill_me = 1;
} else {
/* mostly expected case */
}
}
-int ibwtest_parse_attrs(struct ibwtest_ctx *tcx, char *optext,
+static int ibwtest_parse_attrs(struct ibwtest_ctx *tcx, char *optext,
struct ibw_initattr **pattrs, int *nattrs, char op)
{
int i = 0, n = 1;
return 0;
}
-int ibwtest_getdests(struct ibwtest_ctx *tcx, char op)
+static int ibwtest_get_address(const char *address, struct in_addr *addr)
+{
+ if (inet_pton(AF_INET, address, addr) <= 0) {
+ struct hostent *he = gethostbyname(address);
+ if (he == NULL || he->h_length > sizeof(*addr)) {
+ DEBUG(DEBUG_ERR, ("invalid network address '%s'\n", address));
+ return -1;
+ }
+ memcpy(addr, he->h_addr, he->h_length);
+ }
+ return 0;
+}
+
+static int ibwtest_getdests(struct ibwtest_ctx *tcx, char op)
{
int i;
struct ibw_initattr *attrs = NULL;
char *tmp;
tmp = talloc_strdup(tcx, optarg);
+ if (tmp == NULL) return -1;
/* hack to reuse the above ibw_initattr parser */
if (ibwtest_parse_attrs(tcx, tmp, &attrs, &tcx->naddrs, op))
return -1;
for(i=0; i<tcx->naddrs; i++) {
p = tcx->addrs + i;
p->sin_family = AF_INET;
- p->sin_addr.s_addr = inet_addr(attrs[i].name);
+ if (ibwtest_get_address(attrs[i].name, &p->sin_addr))
+ return -1;
p->sin_port = htons(atoi(attrs[i].value));
}
return 0;
}
-int ibwtest_init_server(struct ibwtest_ctx *tcx)
+static int ibwtest_init_server(struct ibwtest_ctx *tcx)
{
if (tcx->naddrs!=1) {
fprintf(stderr, "incorrect number of addrs(%d!=1)\n", tcx->naddrs);
}
if (ibw_bind(tcx->ibwctx, &tcx->addrs[0])) {
- DEBUG(0, ("ERROR: ibw_bind failed\n"));
+ DEBUG(DEBUG_ERR, ("ERROR: ibw_bind failed\n"));
return -1;
}
if (ibw_listen(tcx->ibwctx, 1)) {
- DEBUG(0, ("ERROR: ibw_listen failed\n"));
+ DEBUG(DEBUG_ERR, ("ERROR: ibw_listen failed\n"));
return -1;
}
return 0;
}
-void ibwtest_usage(struct ibwtest_ctx *tcx, char *name)
+static void ibwtest_usage(struct ibwtest_ctx *tcx, char *name)
{
printf("Usage:\n");
printf("\t%s -i <id> -o {name:value} -d {addr:port} -t nsec -s\n", name);
printf("\t-i <id> is a free text, acting as a server id, max 23 chars [mandatory]\n");
printf("\t-o name1:value1,name2:value2,... is a list of (name, value) pairs\n");
- printf("\t-d addr1:port1,addr2:port2,... is a list of destination ip addresses\n");
+ printf("\t-a addr1:port1,addr2:port2,... is a list of destination ip addresses\n");
printf("\t-t nsec delta time between sends in nanosec [default %d]\n", tcx->nsec);
printf("\t\t send message periodically and endless when nsec is non-zero\n");
printf("\t-s server mode (you have to give exactly one -d address:port in this case)\n");
printf("\t-n number of messages to send [default %d]\n", tcx->nmsg);
printf("\t-l usec time to sleep in the main loop [default %d]\n", tcx->sleep_usec);
printf("\t-v max variable msg size in bytes [default %d], 0=don't send var. size\n", tcx->maxsize);
+ printf("\t-d LogLevel [default %d]\n", DEBUGLEVEL);
printf("Press ctrl+C to stop the program.\n");
}
{
int rc, op;
int result = 1;
- struct event_context *ev = NULL;
+ struct tevent_context *ev = NULL;
struct ibwtest_ctx *tcx = NULL;
float usec;
memset(tcx, 0, sizeof(struct ibwtest_ctx));
tcx->nsec = 0;
tcx->nmsg = 1000;
+ debuglevel_set(0);
/* here is the only case we can't avoid using global... */
testctx = tcx;
signal(SIGINT, ibwtest_sigint_handler);
srand((unsigned)time(NULL));
- while ((op=getopt(argc, argv, "i:o:d:m:st:n:l:v:")) != -1) {
+ while ((op=getopt(argc, argv, "i:o:d:m:st:n:l:v:a:")) != -1) {
switch (op) {
case 'i':
tcx->id = talloc_strdup(tcx, optarg);
break;
case 'o':
tcx->opts = talloc_strdup(tcx, optarg);
+ if (tcx->opts) goto cleanup;
if (ibwtest_parse_attrs(tcx, tcx->opts, &tcx->attrs,
&tcx->nattrs, op))
goto cleanup;
break;
- case 'd':
+ case 'a':
if (ibwtest_getdests(tcx, op))
goto cleanup;
break;
case 'v':
tcx->maxsize = (unsigned int)atoi(optarg);
break;
+ case 'd':
+ debuglevel_set(atoi(optarg));
+ break;
default:
fprintf(stderr, "ERROR: unknown option -%c\n", (char)op);
ibwtest_usage(tcx, argv[0]);
goto cleanup;
}
- ev = event_context_init(NULL);
+ ev = tevent_context_init(NULL);
assert(ev);
tcx->ibwctx = ibw_init(tcx->attrs, tcx->nattrs,
while(!tcx->kill_me && !tcx->error) {
if (tcx->nsec) {
- event_add_timed(ev, tcx, timeval_current_ofs(0, tcx->nsec),
- ibwtest_timeout_handler, tcx);
+ tevent_add_timer(ev, tcx,
+ timeval_current_ofs(0, tcx->nsec),
+ ibwtest_timeout_handler, tcx);
}
- event_loop_once(ev);
+ tevent_loop_once(ev);
if (tcx->sleep_usec)
usleep(tcx->sleep_usec);
if (!tcx->is_server && tcx->nsent!=0 && !tcx->error) {
if (gettimeofday(&tcx->end_time, NULL)) {
- DEBUG(0, ("gettimeofday error %d\n", errno));
+ DEBUG(DEBUG_ERR, ("gettimeofday error %d\n", errno));
goto cleanup;
}
usec = (tcx->end_time.tv_sec - tcx->start_time.tv_sec) * 1000000 +
talloc_free(tcx);
if (ev)
talloc_free(ev);
- DEBUG(0, ("exited with code %d\n", result));
+ DEBUG(DEBUG_ERR, ("exited with code %d\n", result));
return result;
}