ok_null
for i in $(seq 1 1000) ; do
- unit_test protocol_types_test $i
+ unit_test protocol_basic_test $i
done
. "${TEST_SCRIPTS_DIR}/unit.sh"
-last_control=150
+ok_null
-control_output=$(
- for i in $(seq 0 $last_control) ; do
- echo -n "$i.. "
- done
- echo
-)
-
-last_command=5
-
-command_output=$(
- for i in $(seq 1 $last_command) ; do
- echo -n "$i.. "
- done
- echo
-)
-
-output=$(
- echo "ctdb_req_header"
- echo "ctdb_req_call"
- echo "ctdb_reply_call"
- echo "ctdb_reply_error"
- echo "ctdb_req_dmaster"
- echo "ctdb_reply_dmaster"
- echo "ctdb_req_control_data"
- echo "$control_output"
- echo "ctdb_reply_control_data"
- echo "$control_output"
- echo "ctdb_req_control"
- echo "$control_output"
- echo "ctdb_reply_control"
- echo "$control_output"
- echo "ctdb_req_message"
- echo "ctdb_event_header"
- echo "ctdb_event_request_data"
- echo "$command_output"
- echo "ctdb_event_reply_data"
- echo "$command_output"
- echo "ctdb_event_request"
- echo "$command_output"
- echo "ctdb_event_reply"
- echo "$command_output"
-)
-
-ok "$output"
-
-for i in $(seq 1 100) ; do
- unit_test protocol_client_test $i
+for i in $(seq 1 1000) ; do
+ unit_test protocol_types_test $i
done
--- /dev/null
+#!/bin/sh
+
+. "${TEST_SCRIPTS_DIR}/unit.sh"
+
+last_control=150
+
+control_output=$(
+ for i in $(seq 0 $last_control) ; do
+ echo -n "$i.. "
+ done
+ echo
+)
+
+output=$(
+ echo "ctdb_req_header"
+ echo "ctdb_req_call"
+ echo "ctdb_reply_call"
+ echo "ctdb_reply_error"
+ echo "ctdb_req_dmaster"
+ echo "ctdb_reply_dmaster"
+ echo "ctdb_req_control_data"
+ echo "$control_output"
+ echo "ctdb_reply_control_data"
+ echo "$control_output"
+ echo "ctdb_req_control"
+ echo "$control_output"
+ echo "ctdb_reply_control"
+ echo "$control_output"
+ echo "ctdb_req_message"
+)
+
+ok "$output"
+
+for i in $(seq 1 100) ; do
+ unit_test protocol_ctdb_test $i
+done
--- /dev/null
+#!/bin/sh
+
+. "${TEST_SCRIPTS_DIR}/unit.sh"
+
+last_command=5
+
+command_output=$(
+ for i in $(seq 1 $last_command) ; do
+ echo -n "$i.. "
+ done
+ echo
+)
+
+output=$(
+ echo "ctdb_event_header"
+ echo "ctdb_event_request_data"
+ echo "$command_output"
+ echo "ctdb_event_reply_data"
+ echo "$command_output"
+ echo "ctdb_event_request"
+ echo "$command_output"
+ echo "ctdb_event_reply"
+ echo "$command_output"
+)
+
+ok "$output"
+
+for i in $(seq 1 100) ; do
+ unit_test protocol_event_test $i
+done
--- /dev/null
+/*
+ protocol types tests
+
+ Copyright (C) Amitay Isaacs 2015-2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <assert.h>
+
+#include "protocol/protocol_basic.c"
+#include "protocol/protocol_types.c"
+
+#include "tests/src/protocol_common.h"
+
+
+static void test_ctdb_int32(void)
+{
+ int32_t p1, p2;
+ size_t buflen;
+ int ret;
+
+ p1 = rand32i();
+ buflen = ctdb_int32_len(p1);
+ ctdb_int32_push(p1, BUFFER);
+ ret = ctdb_int32_pull(BUFFER, buflen, NULL, &p2);
+ assert(ret == 0);
+ assert(p1 == p2);
+}
+
+static void test_ctdb_uint32(void)
+{
+ uint32_t p1, p2;
+ size_t buflen;
+ int ret;
+
+ p1 = rand32();
+ buflen = ctdb_uint32_len(p1);
+ ctdb_uint32_push(p1, BUFFER);
+ ret = ctdb_uint32_pull(BUFFER, buflen, NULL, &p2);
+ assert(ret == 0);
+ assert(p1 == p2);
+}
+
+static void test_ctdb_uint64(void)
+{
+ uint64_t p1, p2;
+ size_t buflen;
+ int ret;
+
+ p1 = rand64();
+ buflen = ctdb_uint64_len(p1);
+ ctdb_uint64_push(p1, BUFFER);
+ ret = ctdb_uint64_pull(BUFFER, buflen, NULL, &p2);
+ assert(ret == 0);
+ assert(p1 == p2);
+}
+
+static void test_ctdb_double(void)
+{
+ double p1, p2;
+ size_t buflen;
+ int ret;
+
+ p1 = rand_double();
+ buflen = ctdb_double_len(p1);
+ ctdb_double_push(p1, BUFFER);
+ ret = ctdb_double_pull(BUFFER, buflen, NULL, &p2);
+ assert(ret == 0);
+ assert(p1 == p2);
+}
+
+static void test_ctdb_string(void)
+{
+ TALLOC_CTX *mem_ctx = talloc_new(NULL);
+ const char *p1, *p2;
+ size_t buflen;
+ int ret;
+
+ fill_ctdb_string(mem_ctx, &p1);
+ buflen = ctdb_string_len(p1);
+ ctdb_string_push(p1, BUFFER);
+ ret = ctdb_string_pull(BUFFER, buflen, mem_ctx, &p2);
+ assert(ret == 0);
+ verify_ctdb_string(p1, p2);
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_stringn(void)
+{
+ TALLOC_CTX *mem_ctx = talloc_new(NULL);
+ const char *p1, *p2;
+ size_t buflen;
+ int ret;
+
+ fill_ctdb_string(mem_ctx, &p1);
+ buflen = ctdb_stringn_len(p1);
+ ctdb_stringn_push(p1, BUFFER);
+ ret = ctdb_stringn_pull(BUFFER, buflen, mem_ctx, &p2);
+ assert(ret == 0);
+ verify_ctdb_string(p1, p2);
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_pid(void)
+{
+ pid_t p1, p2;
+ size_t buflen;
+ int ret;
+
+ p1 = rand32();
+ buflen = ctdb_pid_len(p1);
+ ctdb_pid_push(p1, BUFFER);
+ ret = ctdb_pid_pull(BUFFER, buflen, NULL, &p2);
+ assert(ret == 0);
+ assert(p1 == p2);
+}
+
+int main(int argc, char *argv[])
+{
+ if (argc == 2) {
+ int seed = atoi(argv[1]);
+ srandom(seed);
+ }
+
+ test_ctdb_int32();
+ test_ctdb_uint32();
+ test_ctdb_uint64();
+ test_ctdb_double();
+
+ test_ctdb_string();
+ test_ctdb_stringn();
+
+ test_ctdb_pid();
+
+ return 0;
+}
--- /dev/null
+/*
+ protocol tests - common functions
+
+ Copyright (C) Amitay Isaacs 2015-2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <assert.h>
+
+#include "protocol/protocol_api.h"
+
+#include "tests/src/protocol_common.h"
+
+uint8_t BUFFER[1024*1024];
+
+/*
+ * Functions to generation random data
+ */
+
+int rand_int(int max)
+{
+ return random() % max;
+}
+
+uint8_t rand8(void)
+{
+ uint8_t val = rand_int(256) & 0xff;
+ return val;
+}
+
+int32_t rand32i(void)
+{
+ return INT_MIN + random();
+}
+
+uint32_t rand32(void)
+{
+ return random();
+}
+
+uint64_t rand64(void)
+{
+ uint64_t t = random();
+ t = (t << 32) | random();
+ return t;
+}
+
+double rand_double(void)
+{
+ return 1.0 / rand64();
+}
+
+void fill_buffer(void *p, size_t len)
+{
+ int i;
+ uint8_t *ptr = p;
+
+ for (i=0; i<len; i++) {
+ ptr[i] = rand8();
+ }
+}
+
+void verify_buffer(void *p1, void *p2, size_t len)
+{
+ if (len > 0) {
+ assert(memcmp(p1, p2, len) == 0);
+ }
+}
+
+void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **out)
+{
+ char *p;
+ int len, i;
+
+ len = rand_int(1024) + 1;
+ p = talloc_size(mem_ctx, len+1);
+ assert(p != NULL);
+
+ for (i=0; i<len; i++) {
+ p[i] = 'A' + rand_int(26);
+ }
+ p[len] = '\0';
+ *out = p;
+}
+
+void verify_ctdb_string(const char *p1, const char *p2)
+{
+ if (p1 == NULL || p2 == NULL) {
+ assert(p1 == p2);
+ } else {
+ assert(strlen(p1) == strlen(p2));
+ assert(strcmp(p1, p2) == 0);
+ }
+}
+
+void fill_tdb_data_nonnull(TALLOC_CTX *mem_ctx, TDB_DATA *p)
+{
+ p->dsize = rand_int(1024) + 1;
+ p->dptr = talloc_array(mem_ctx, uint8_t, p->dsize);
+ assert(p->dptr != NULL);
+ fill_buffer(p->dptr, p->dsize);
+}
+
+void fill_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p)
+{
+ if (rand_int(5) == 0) {
+ p->dsize = 0;
+ p->dptr = NULL;
+ } else {
+ fill_tdb_data_nonnull(mem_ctx, p);
+ }
+}
+
+void verify_tdb_data(TDB_DATA *p1, TDB_DATA *p2)
+{
+ assert(p1->dsize == p2->dsize);
+ verify_buffer(p1->dptr, p2->dptr, p1->dsize);
+}
+
+void fill_ctdb_statistics(TALLOC_CTX *mem_ctx, struct ctdb_statistics *p)
+{
+ fill_buffer((uint8_t *)p, sizeof(struct ctdb_statistics));
+}
+
+void verify_ctdb_statistics(struct ctdb_statistics *p1,
+ struct ctdb_statistics *p2)
+{
+ verify_buffer(p1, p2, sizeof(struct ctdb_statistics));
+}
+
+void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p)
+{
+ int i;
+
+ p->generation = rand32();
+ p->size = rand_int(20);
+ if (p->size > 0) {
+ p->map = talloc_array(mem_ctx, uint32_t, p->size);
+ assert(p->map != NULL);
+
+ for (i=0; i<p->size; i++) {
+ p->map[i] = rand32();
+ }
+ } else {
+ p->map = NULL;
+ }
+}
+
+void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1, struct ctdb_vnn_map *p2)
+{
+ int i;
+
+ assert(p1->generation == p2->generation);
+ assert(p1->size == p2->size);
+ for (i=0; i<p1->size; i++) {
+ assert(p1->map[i] == p2->map[i]);
+ }
+}
+
+void fill_ctdb_dbid(TALLOC_CTX *mem_ctx, struct ctdb_dbid *p)
+{
+ p->db_id = rand32();
+ p->flags = rand8();
+}
+
+void verify_ctdb_dbid(struct ctdb_dbid *p1, struct ctdb_dbid *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->flags == p2->flags);
+}
+
+void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p)
+{
+ int i;
+
+ p->num = rand_int(40);
+ if (p->num > 0) {
+ p->dbs = talloc_array(mem_ctx, struct ctdb_dbid, p->num);
+ assert(p->dbs != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_dbid(mem_ctx, &p->dbs[i]);
+ }
+ } else {
+ p->dbs = NULL;
+ }
+}
+
+void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1, struct ctdb_dbid_map *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_dbid(&p1->dbs[i], &p2->dbs[i]);
+ }
+}
+
+void fill_ctdb_pulldb(TALLOC_CTX *mem_ctx, struct ctdb_pulldb *p)
+{
+ p->db_id = rand32();
+ p->lmaster = rand32();
+}
+
+void verify_ctdb_pulldb(struct ctdb_pulldb *p1, struct ctdb_pulldb *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->lmaster == p2->lmaster);
+}
+
+void fill_ctdb_pulldb_ext(TALLOC_CTX *mem_ctx, struct ctdb_pulldb_ext *p)
+{
+ p->db_id = rand32();
+ p->lmaster = rand32();
+ p->srvid = rand64();
+}
+
+void verify_ctdb_pulldb_ext(struct ctdb_pulldb_ext *p1,
+ struct ctdb_pulldb_ext *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->lmaster == p2->lmaster);
+ assert(p1->srvid == p2->srvid);
+}
+
+void fill_ctdb_ltdb_header(TALLOC_CTX *mem_ctx, struct ctdb_ltdb_header *p)
+{
+ p->rsn = rand64();
+ p->dmaster = rand32();
+ p->flags = rand32();
+}
+
+void verify_ctdb_ltdb_header(struct ctdb_ltdb_header *p1,
+ struct ctdb_ltdb_header *p2)
+{
+ assert(p1->rsn == p2->rsn);
+ assert(p1->dmaster == p2->dmaster);
+ assert(p1->flags == p2->flags);
+}
+
+void fill_ctdb_rec_data(TALLOC_CTX *mem_ctx, struct ctdb_rec_data *p)
+{
+ p->reqid = rand32();
+ if (p->reqid % 5 == 0) {
+ p->header = talloc(mem_ctx, struct ctdb_ltdb_header);
+ assert(p->header != NULL);
+ fill_ctdb_ltdb_header(mem_ctx, p->header);
+ } else {
+ p->header = NULL;
+ }
+ fill_tdb_data_nonnull(mem_ctx, &p->key);
+ fill_tdb_data(mem_ctx, &p->data);
+}
+
+void verify_ctdb_rec_data(struct ctdb_rec_data *p1, struct ctdb_rec_data *p2)
+{
+ struct ctdb_ltdb_header header;
+
+ assert(p1->reqid == p2->reqid);
+ if (p1->header != NULL) {
+ assert(ctdb_ltdb_header_extract(&p2->data, &header) == 0);
+ verify_ctdb_ltdb_header(p1->header, &header);
+ }
+ verify_tdb_data(&p1->key, &p2->key);
+ verify_tdb_data(&p1->data, &p2->data);
+}
+
+void fill_ctdb_rec_buffer(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *p)
+{
+ struct ctdb_rec_data rec;
+ int ret, i;
+ int count;
+
+ p->db_id = rand32();
+ p->count = 0;
+ p->buf = NULL;
+ p->buflen = 0;
+
+ count = rand_int(100);
+ if (count > 0) {
+ for (i=0; i<count; i++) {
+ fill_ctdb_rec_data(mem_ctx, &rec);
+ ret = ctdb_rec_buffer_add(mem_ctx, p, rec.reqid,
+ rec.header,
+ rec.key, rec.data);
+ assert(ret == 0);
+ }
+ }
+}
+
+void verify_ctdb_rec_buffer(struct ctdb_rec_buffer *p1,
+ struct ctdb_rec_buffer *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->count == p2->count);
+ assert(p1->buflen == p2->buflen);
+ verify_buffer(p1->buf, p2->buf, p1->buflen);
+}
+
+void fill_ctdb_traverse_start(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_start *p)
+{
+ p->db_id = rand32();
+ p->reqid = rand32();
+ p->srvid = rand64();
+}
+
+void verify_ctdb_traverse_start(struct ctdb_traverse_start *p1,
+ struct ctdb_traverse_start *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->reqid == p2->reqid);
+ assert(p1->srvid == p2->srvid);
+}
+
+void fill_ctdb_traverse_all(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_all *p)
+{
+ p->db_id = rand32();
+ p->reqid = rand32();
+ p->pnn = rand32();
+ p->client_reqid = rand32();
+ p->srvid = rand64();
+}
+
+void verify_ctdb_traverse_all(struct ctdb_traverse_all *p1,
+ struct ctdb_traverse_all *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->reqid == p2->reqid);
+ assert(p1->pnn == p2->pnn);
+ assert(p1->client_reqid == p2->client_reqid);
+ assert(p1->srvid == p2->srvid);
+}
+
+void fill_ctdb_traverse_start_ext(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_start_ext *p)
+{
+ p->db_id = rand32();
+ p->reqid = rand32();
+ p->srvid = rand64();
+ p->withemptyrecords = rand_int(2);
+}
+
+void verify_ctdb_traverse_start_ext(struct ctdb_traverse_start_ext *p1,
+ struct ctdb_traverse_start_ext *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->reqid == p2->reqid);
+ assert(p1->srvid == p2->srvid);
+ assert(p1->withemptyrecords == p2->withemptyrecords);
+}
+
+void fill_ctdb_traverse_all_ext(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_all_ext *p)
+{
+ p->db_id = rand32();
+ p->reqid = rand32();
+ p->pnn = rand32();
+ p->client_reqid = rand32();
+ p->srvid = rand64();
+ p->withemptyrecords = rand_int(2);
+}
+
+void verify_ctdb_traverse_all_ext(struct ctdb_traverse_all_ext *p1,
+ struct ctdb_traverse_all_ext *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->reqid == p2->reqid);
+ assert(p1->pnn == p2->pnn);
+ assert(p1->client_reqid == p2->client_reqid);
+ assert(p1->srvid == p2->srvid);
+ assert(p1->withemptyrecords == p2->withemptyrecords);
+}
+
+void fill_ctdb_sock_addr(TALLOC_CTX *mem_ctx, ctdb_sock_addr *p)
+{
+ if (rand_int(2) == 0) {
+ p->ip.sin_family = AF_INET;
+ p->ip.sin_port = rand_int(65535);
+ fill_buffer(&p->ip.sin_addr, sizeof(struct in_addr));
+ } else {
+ p->ip6.sin6_family = AF_INET6;
+ p->ip6.sin6_port = rand_int(65535);
+ fill_buffer(&p->ip6.sin6_addr, sizeof(struct in6_addr));
+ }
+}
+
+void verify_ctdb_sock_addr(ctdb_sock_addr *p1, ctdb_sock_addr *p2)
+{
+ assert(p1->sa.sa_family == p2->sa.sa_family);
+ if (p1->sa.sa_family == AF_INET) {
+ assert(p1->ip.sin_port == p2->ip.sin_port);
+ verify_buffer(&p1->ip.sin_addr, &p2->ip.sin_addr,
+ sizeof(struct in_addr));
+ } else {
+ assert(p1->ip6.sin6_port == p2->ip6.sin6_port);
+ verify_buffer(&p1->ip6.sin6_addr, &p2->ip6.sin6_addr,
+ sizeof(struct in6_addr));
+ }
+}
+
+void fill_ctdb_connection(TALLOC_CTX *mem_ctx, struct ctdb_connection *p)
+{
+ fill_ctdb_sock_addr(mem_ctx, &p->src);
+ fill_ctdb_sock_addr(mem_ctx, &p->dst);
+}
+
+void verify_ctdb_connection(struct ctdb_connection *p1,
+ struct ctdb_connection *p2)
+{
+ verify_ctdb_sock_addr(&p1->src, &p2->src);
+ verify_ctdb_sock_addr(&p1->dst, &p2->dst);
+}
+
+void fill_ctdb_tunable(TALLOC_CTX *mem_ctx, struct ctdb_tunable *p)
+{
+ fill_ctdb_string(mem_ctx, discard_const(&p->name));
+ p->value = rand32();
+}
+
+void verify_ctdb_tunable(struct ctdb_tunable *p1, struct ctdb_tunable *p2)
+{
+ verify_ctdb_string(discard_const(p1->name), discard_const(p2->name));
+ assert(p1->value == p2->value);
+}
+
+void fill_ctdb_node_flag_change(TALLOC_CTX *mem_ctx,
+ struct ctdb_node_flag_change *p)
+{
+ p->pnn = rand32();
+ p->new_flags = rand32();
+ p->old_flags = rand32();
+}
+
+void verify_ctdb_node_flag_change(struct ctdb_node_flag_change *p1,
+ struct ctdb_node_flag_change *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ assert(p1->new_flags == p2->new_flags);
+ assert(p1->old_flags == p2->old_flags);
+}
+
+void fill_ctdb_var_list(TALLOC_CTX *mem_ctx, struct ctdb_var_list *p)
+{
+ int i;
+
+ p->count = rand_int(100) + 1;
+ p->var = talloc_array(mem_ctx, const char *, p->count);
+ for (i=0; i<p->count; i++) {
+ fill_ctdb_string(p->var, discard_const(&p->var[i]));
+ }
+}
+
+void verify_ctdb_var_list(struct ctdb_var_list *p1, struct ctdb_var_list *p2)
+{
+ int i;
+
+ assert(p1->count == p2->count);
+ for (i=0; i<p1->count; i++) {
+ verify_ctdb_string(discard_const(p1->var[i]),
+ discard_const(p2->var[i]));
+ }
+}
+
+void fill_ctdb_tunable_list(TALLOC_CTX *mem_ctx, struct ctdb_tunable_list *p)
+{
+ fill_buffer(p, sizeof(struct ctdb_tunable_list));
+}
+
+void verify_ctdb_tunable_list(struct ctdb_tunable_list *p1,
+ struct ctdb_tunable_list *p2)
+{
+ verify_buffer(p1, p2, sizeof(struct ctdb_tunable_list));
+}
+
+void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx, struct ctdb_tickle_list *p)
+{
+ int i;
+
+ fill_ctdb_sock_addr(mem_ctx, &p->addr);
+ p->num = rand_int(1000);
+ if (p->num > 0) {
+ p->conn = talloc_array(mem_ctx, struct ctdb_connection, p->num);
+ assert(p->conn != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_connection(mem_ctx, &p->conn[i]);
+ }
+ } else {
+ p->conn = NULL;
+ }
+}
+
+void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
+ struct ctdb_tickle_list *p2)
+{
+ int i;
+
+ verify_ctdb_sock_addr(&p1->addr, &p2->addr);
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_connection(&p1->conn[i], &p2->conn[i]);
+ }
+}
+
+void fill_ctdb_addr_info(TALLOC_CTX *mem_ctx, struct ctdb_addr_info *p)
+{
+ fill_ctdb_sock_addr(mem_ctx, &p->addr);
+ p->mask = rand_int(33);
+ if (rand_int(2) == 0) {
+ p->iface = NULL;
+ } else {
+ fill_ctdb_string(mem_ctx, &p->iface);
+ }
+}
+
+void verify_ctdb_addr_info(struct ctdb_addr_info *p1,
+ struct ctdb_addr_info *p2)
+{
+ verify_ctdb_sock_addr(&p1->addr, &p2->addr);
+ assert(p1->mask == p2->mask);
+ verify_ctdb_string(p1->iface, p2->iface);
+}
+
+void fill_ctdb_transdb(TALLOC_CTX *mem_ctx, struct ctdb_transdb *p)
+{
+ p->db_id = rand32();
+ p->tid = rand32();
+}
+
+void verify_ctdb_transdb(struct ctdb_transdb *p1, struct ctdb_transdb *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ assert(p1->tid == p2->tid);
+}
+
+void fill_ctdb_uptime(TALLOC_CTX *mem_ctx, struct ctdb_uptime *p)
+{
+ fill_buffer(p, sizeof(struct ctdb_uptime));
+}
+
+void verify_ctdb_uptime(struct ctdb_uptime *p1, struct ctdb_uptime *p2)
+{
+ verify_buffer(p1, p2, sizeof(struct ctdb_uptime));
+}
+
+void fill_ctdb_public_ip(TALLOC_CTX *mem_ctx, struct ctdb_public_ip *p)
+{
+ p->pnn = rand32();
+ fill_ctdb_sock_addr(mem_ctx, &p->addr);
+}
+
+void verify_ctdb_public_ip(struct ctdb_public_ip *p1,
+ struct ctdb_public_ip *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ verify_ctdb_sock_addr(&p1->addr, &p2->addr);
+}
+
+void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_public_ip_list *p)
+{
+ int i;
+
+ p->num = rand_int(32);
+ if (p->num > 0) {
+ p->ip = talloc_array(mem_ctx, struct ctdb_public_ip, p->num);
+ assert(p->ip != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_public_ip(mem_ctx, &p->ip[i]);
+ }
+ } else {
+ p->ip = NULL;
+ }
+}
+
+void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
+ struct ctdb_public_ip_list *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_public_ip(&p1->ip[i], &p2->ip[i]);
+ }
+}
+
+void fill_ctdb_node_and_flags(TALLOC_CTX *mem_ctx,
+ struct ctdb_node_and_flags *p)
+{
+ p->pnn = rand32();
+ p->flags = rand32();
+ fill_ctdb_sock_addr(mem_ctx, &p->addr);
+}
+
+void verify_ctdb_node_and_flags(struct ctdb_node_and_flags *p1,
+ struct ctdb_node_and_flags *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ assert(p1->flags == p2->flags);
+ verify_ctdb_sock_addr(&p1->addr, &p2->addr);
+}
+
+void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p)
+{
+ int i;
+
+ p->num = rand_int(32);
+ if (p->num > 0) {
+ p->node = talloc_array(mem_ctx, struct ctdb_node_and_flags,
+ p->num);
+ assert(p->node != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_node_and_flags(mem_ctx, &p->node[i]);
+ }
+ } else {
+ p->node = NULL;
+ }
+}
+
+void verify_ctdb_node_map(struct ctdb_node_map *p1, struct ctdb_node_map *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_node_and_flags(&p1->node[i], &p2->node[i]);
+ }
+}
+
+void fill_ctdb_script(TALLOC_CTX *mem_ctx, struct ctdb_script *p)
+{
+ fill_buffer(p, sizeof(struct ctdb_script));
+}
+
+void verify_ctdb_script(struct ctdb_script *p1, struct ctdb_script *p2)
+{
+ verify_buffer(p1, p2, sizeof(struct ctdb_script));
+}
+
+void fill_ctdb_script_list(TALLOC_CTX *mem_ctx, struct ctdb_script_list *p)
+{
+ int i;
+
+ p->num_scripts = rand_int(32);
+ if (p->num_scripts > 0) {
+ p->script = talloc_array(mem_ctx, struct ctdb_script,
+ p->num_scripts);
+ assert(p->script != NULL);
+ for (i=0; i<p->num_scripts; i++) {
+ fill_ctdb_script(mem_ctx, &p->script[i]);
+ }
+ } else {
+ p->script = NULL;
+ }
+}
+
+void verify_ctdb_script_list(struct ctdb_script_list *p1,
+ struct ctdb_script_list *p2)
+{
+ int i;
+
+ assert(p1->num_scripts == p2->num_scripts);
+ for (i=0; i<p1->num_scripts; i++) {
+ verify_ctdb_script(&p1->script[i], &p2->script[i]);
+ }
+}
+
+void fill_ctdb_ban_state(TALLOC_CTX *mem_ctx, struct ctdb_ban_state *p)
+{
+ p->pnn = rand32();
+ p->time = rand32();
+}
+
+void verify_ctdb_ban_state(struct ctdb_ban_state *p1,
+ struct ctdb_ban_state *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ assert(p1->time == p2->time);
+}
+
+void fill_ctdb_notify_data(TALLOC_CTX *mem_ctx, struct ctdb_notify_data *p)
+{
+ p->srvid = rand64();
+ fill_tdb_data(mem_ctx, &p->data);
+}
+
+void verify_ctdb_notify_data(struct ctdb_notify_data *p1,
+ struct ctdb_notify_data *p2)
+{
+ assert(p1->srvid == p2->srvid);
+ verify_tdb_data(&p1->data, &p2->data);
+}
+
+void fill_ctdb_iface(TALLOC_CTX *mem_ctx, struct ctdb_iface *p)
+{
+ fill_buffer(p, sizeof(struct ctdb_iface));
+}
+
+void verify_ctdb_iface(struct ctdb_iface *p1, struct ctdb_iface *p2)
+{
+ verify_buffer(p1, p2, sizeof(struct ctdb_iface));
+}
+
+void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx, struct ctdb_iface_list *p)
+{
+ int i;
+
+ p->num = rand_int(32);
+ if (p->num > 0) {
+ p->iface = talloc_array(mem_ctx, struct ctdb_iface, p->num);
+ assert(p->iface != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_iface(mem_ctx, &p->iface[i]);
+ }
+ } else {
+ p->iface = NULL;
+ }
+}
+
+void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
+ struct ctdb_iface_list *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_iface(&p1->iface[i], &p2->iface[i]);
+ }
+}
+
+void fill_ctdb_public_ip_info(TALLOC_CTX *mem_ctx,
+ struct ctdb_public_ip_info *p)
+{
+ fill_ctdb_public_ip(mem_ctx, &p->ip);
+ p->active_idx = rand_int(32) + 1;
+ p->ifaces = talloc(mem_ctx, struct ctdb_iface_list);
+ assert(p->ifaces != NULL);
+ fill_ctdb_iface_list(mem_ctx, p->ifaces);
+}
+
+void verify_ctdb_public_ip_info(struct ctdb_public_ip_info *p1,
+ struct ctdb_public_ip_info *p2)
+{
+ verify_ctdb_public_ip(&p1->ip, &p2->ip);
+ assert(p1->active_idx == p2->active_idx);
+ verify_ctdb_iface_list(p1->ifaces, p2->ifaces);
+}
+
+void fill_ctdb_statistics_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_statistics_list *p)
+{
+ int i;
+
+ p->num = rand_int(10);
+ if (p->num > 0) {
+ p->stats = talloc_array(mem_ctx, struct ctdb_statistics,
+ p->num);
+ assert(p->stats != NULL);
+
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_statistics(mem_ctx, &p->stats[i]);
+ }
+ } else {
+ p->stats = NULL;
+ }
+}
+
+void verify_ctdb_statistics_list(struct ctdb_statistics_list *p1,
+ struct ctdb_statistics_list *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_statistics(&p1->stats[i], &p2->stats[i]);
+ }
+}
+
+void fill_ctdb_key_data(TALLOC_CTX *mem_ctx, struct ctdb_key_data *p)
+{
+ p->db_id = rand32();
+ fill_ctdb_ltdb_header(mem_ctx, &p->header);
+ fill_tdb_data_nonnull(mem_ctx, &p->key);
+}
+
+void verify_ctdb_key_data(struct ctdb_key_data *p1, struct ctdb_key_data *p2)
+{
+ assert(p1->db_id == p2->db_id);
+ verify_ctdb_ltdb_header(&p1->header, &p2->header);
+ verify_tdb_data(&p1->key, &p2->key);
+}
+
+void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
+ struct ctdb_db_statistics *p)
+{
+ int i;
+
+ fill_buffer(p, offsetof(struct ctdb_db_statistics, num_hot_keys));
+ p->num_hot_keys = 10;
+ for (i=0; i<p->num_hot_keys; i++) {
+ p->hot_keys[i].count = rand32();
+ fill_tdb_data(mem_ctx, &p->hot_keys[i].key);
+ }
+}
+
+void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
+ struct ctdb_db_statistics *p2)
+{
+ int i;
+
+ verify_buffer(p1, p2, offsetof(struct ctdb_db_statistics,
+ num_hot_keys));
+ assert(p1->num_hot_keys == p2->num_hot_keys);
+ for (i=0; i<p1->num_hot_keys; i++) {
+ assert(p1->hot_keys[i].count == p2->hot_keys[i].count);
+ verify_tdb_data(&p1->hot_keys[i].key, &p2->hot_keys[i].key);
+ }
+}
+
+void fill_ctdb_election_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_election_message *p)
+{
+ p->num_connected = rand_int(32);
+ fill_buffer(&p->priority_time, sizeof(struct timeval));
+ p->pnn = rand_int(32);
+ p->node_flags = rand32();
+}
+
+void verify_ctdb_election_message(struct ctdb_election_message *p1,
+ struct ctdb_election_message *p2)
+{
+ assert(p1->num_connected == p2->num_connected);
+ verify_buffer(p1, p2, sizeof(struct timeval));
+ assert(p1->pnn == p2->pnn);
+ assert(p1->node_flags == p2->node_flags);
+}
+
+void fill_ctdb_srvid_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_srvid_message *p)
+{
+ p->pnn = rand_int(32);
+ p->srvid = rand64();
+}
+
+void verify_ctdb_srvid_message(struct ctdb_srvid_message *p1,
+ struct ctdb_srvid_message *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ assert(p1->srvid == p2->srvid);
+}
+
+void fill_ctdb_disable_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_disable_message *p)
+{
+ p->pnn = rand_int(32);
+ p->srvid = rand64();
+ p->timeout = rand32();
+}
+
+void verify_ctdb_disable_message(struct ctdb_disable_message *p1,
+ struct ctdb_disable_message *p2)
+{
+ assert(p1->pnn == p2->pnn);
+ assert(p1->srvid == p2->srvid);
+ assert(p1->timeout == p2->timeout);
+}
+
+void fill_ctdb_server_id(TALLOC_CTX *mem_ctx, struct ctdb_server_id *p)
+{
+ p->pid = rand64();
+ p->task_id = rand32();
+ p->vnn = rand_int(32);
+ p->unique_id = rand64();
+}
+
+void verify_ctdb_server_id(struct ctdb_server_id *p1,
+ struct ctdb_server_id *p2)
+{
+ assert(p1->pid == p2->pid);
+ assert(p1->task_id == p2->task_id);
+ assert(p1->vnn == p2->vnn);
+ assert(p1->unique_id == p2->unique_id);
+}
+
+void fill_ctdb_g_lock(TALLOC_CTX *mem_ctx, struct ctdb_g_lock *p)
+{
+ p->type = rand_int(2);
+ fill_ctdb_server_id(mem_ctx, &p->sid);
+}
+
+void verify_ctdb_g_lock(struct ctdb_g_lock *p1, struct ctdb_g_lock *p2)
+{
+ assert(p1->type == p2->type);
+ verify_ctdb_server_id(&p1->sid, &p2->sid);
+}
+
+void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx, struct ctdb_g_lock_list *p)
+{
+ int i;
+
+ p->num = rand_int(20) + 1;
+ p->lock = talloc_array(mem_ctx, struct ctdb_g_lock, p->num);
+ assert(p->lock != NULL);
+ for (i=0; i<p->num; i++) {
+ fill_ctdb_g_lock(mem_ctx, &p->lock[i]);
+ }
+}
+
+void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
+ struct ctdb_g_lock_list *p2)
+{
+ int i;
+
+ assert(p1->num == p2->num);
+ for (i=0; i<p1->num; i++) {
+ verify_ctdb_g_lock(&p1->lock[i], &p2->lock[i]);
+ }
+}
--- /dev/null
+/*
+ protocol tests - common functions
+
+ Copyright (C) Amitay Isaacs 2015-2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __CTDB_PROTOCOL_COMMON_H__
+#define __CTDB_PROTOCOL_COMMON_H__
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <talloc.h>
+#include <tdb.h>
+
+#include "protocol/protocol.h"
+
+/*
+ * Generate test routines
+ */
+
+#define TEST_FUNC(NAME) test_ ##NAME
+#define FILL_FUNC(NAME) fill_ ##NAME
+#define VERIFY_FUNC(NAME) verify_ ##NAME
+#define LEN_FUNC(NAME) NAME## _len
+#define PUSH_FUNC(NAME) NAME## _push
+#define PULL_FUNC(NAME) NAME## _pull
+
+#define DEFINE_TEST(TYPE, NAME) \
+static void TEST_FUNC(NAME)(void) \
+{ \
+ TALLOC_CTX *mem_ctx = talloc_new(NULL); \
+ TYPE *p1, *p2; \
+ size_t buflen; \
+ int ret; \
+\
+ p1 = talloc_zero(mem_ctx, TYPE); \
+ assert(p1 != NULL); \
+ FILL_FUNC(NAME)(p1, p1); \
+ buflen = LEN_FUNC(NAME)(p1); \
+ PUSH_FUNC(NAME)(p1, BUFFER); \
+ ret = PULL_FUNC(NAME)(BUFFER, buflen, mem_ctx, &p2); \
+ assert(ret == 0); \
+ VERIFY_FUNC(NAME)(p1, p2); \
+ talloc_free(mem_ctx); \
+}
+
+extern uint8_t BUFFER[1024*1024];
+
+int rand_int(int max);
+uint8_t rand8(void);
+int32_t rand32i(void);
+uint32_t rand32(void);
+uint64_t rand64(void);
+double rand_double(void);
+
+void fill_buffer(void *p, size_t len);
+void verify_buffer(void *p1, void *p2, size_t len);
+
+void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **out);
+void verify_ctdb_string(const char *p1, const char *p2);
+
+void fill_tdb_data_nonnull(TALLOC_CTX *mem_ctx, TDB_DATA *p);
+void fill_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p);
+void verify_tdb_data(TDB_DATA *p1, TDB_DATA *p2);
+
+void fill_ctdb_statistics(TALLOC_CTX *mem_ctx, struct ctdb_statistics *p);
+void verify_ctdb_statistics(struct ctdb_statistics *p1,
+ struct ctdb_statistics *p2);
+
+void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p);
+void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1, struct ctdb_vnn_map *p2);
+
+void fill_ctdb_dbid(TALLOC_CTX *mem_ctx, struct ctdb_dbid *p);
+void verify_ctdb_dbid(struct ctdb_dbid *p1, struct ctdb_dbid *p2);
+
+void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p);
+void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1, struct ctdb_dbid_map *p2);
+
+void fill_ctdb_pulldb(TALLOC_CTX *mem_ctx, struct ctdb_pulldb *p);
+void verify_ctdb_pulldb(struct ctdb_pulldb *p1, struct ctdb_pulldb *p2);
+
+void fill_ctdb_pulldb_ext(TALLOC_CTX *mem_ctx, struct ctdb_pulldb_ext *p);
+void verify_ctdb_pulldb_ext(struct ctdb_pulldb_ext *p1,
+ struct ctdb_pulldb_ext *p2);
+
+void fill_ctdb_ltdb_header(TALLOC_CTX *mem_ctx, struct ctdb_ltdb_header *p);
+void verify_ctdb_ltdb_header(struct ctdb_ltdb_header *p1,
+ struct ctdb_ltdb_header *p2);
+
+void fill_ctdb_rec_data(TALLOC_CTX *mem_ctx, struct ctdb_rec_data *p);
+void verify_ctdb_rec_data(struct ctdb_rec_data *p1, struct ctdb_rec_data *p2);
+
+void fill_ctdb_rec_buffer(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *p);
+void verify_ctdb_rec_buffer(struct ctdb_rec_buffer *p1,
+ struct ctdb_rec_buffer *p2);
+
+void fill_ctdb_traverse_start(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_start *p);
+void verify_ctdb_traverse_start(struct ctdb_traverse_start *p1,
+ struct ctdb_traverse_start *p2);
+
+void fill_ctdb_traverse_all(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_all *p);
+void verify_ctdb_traverse_all(struct ctdb_traverse_all *p1,
+ struct ctdb_traverse_all *p2);
+
+void fill_ctdb_traverse_start_ext(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_start_ext *p);
+void verify_ctdb_traverse_start_ext(struct ctdb_traverse_start_ext *p1,
+ struct ctdb_traverse_start_ext *p2);
+
+void fill_ctdb_traverse_all_ext(TALLOC_CTX *mem_ctx,
+ struct ctdb_traverse_all_ext *p);
+void verify_ctdb_traverse_all_ext(struct ctdb_traverse_all_ext *p1,
+ struct ctdb_traverse_all_ext *p2);
+
+void fill_ctdb_sock_addr(TALLOC_CTX *mem_ctx, ctdb_sock_addr *p);
+void verify_ctdb_sock_addr(ctdb_sock_addr *p1, ctdb_sock_addr *p2);
+
+void fill_ctdb_connection(TALLOC_CTX *mem_ctx, struct ctdb_connection *p);
+void verify_ctdb_connection(struct ctdb_connection *p1,
+ struct ctdb_connection *p2);
+
+void fill_ctdb_tunable(TALLOC_CTX *mem_ctx, struct ctdb_tunable *p);
+void verify_ctdb_tunable(struct ctdb_tunable *p1, struct ctdb_tunable *p2);
+
+void fill_ctdb_node_flag_change(TALLOC_CTX *mem_ctx,
+ struct ctdb_node_flag_change *p);
+void verify_ctdb_node_flag_change(struct ctdb_node_flag_change *p1,
+ struct ctdb_node_flag_change *p2);
+
+void fill_ctdb_var_list(TALLOC_CTX *mem_ctx, struct ctdb_var_list *p);
+void verify_ctdb_var_list(struct ctdb_var_list *p1, struct ctdb_var_list *p2);
+
+void fill_ctdb_tunable_list(TALLOC_CTX *mem_ctx, struct ctdb_tunable_list *p);
+void verify_ctdb_tunable_list(struct ctdb_tunable_list *p1,
+ struct ctdb_tunable_list *p2);
+
+void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx, struct ctdb_tickle_list *p);
+void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
+ struct ctdb_tickle_list *p2);
+
+void fill_ctdb_addr_info(TALLOC_CTX *mem_ctx, struct ctdb_addr_info *p);
+void verify_ctdb_addr_info(struct ctdb_addr_info *p1,
+ struct ctdb_addr_info *p2);
+
+void fill_ctdb_transdb(TALLOC_CTX *mem_ctx, struct ctdb_transdb *p);
+void verify_ctdb_transdb(struct ctdb_transdb *p1, struct ctdb_transdb *p2);
+
+void fill_ctdb_uptime(TALLOC_CTX *mem_ctx, struct ctdb_uptime *p);
+void verify_ctdb_uptime(struct ctdb_uptime *p1, struct ctdb_uptime *p2);
+
+void fill_ctdb_public_ip(TALLOC_CTX *mem_ctx, struct ctdb_public_ip *p);
+void verify_ctdb_public_ip(struct ctdb_public_ip *p1,
+ struct ctdb_public_ip *p2);
+
+void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_public_ip_list *p);
+void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
+ struct ctdb_public_ip_list *p2);
+
+void fill_ctdb_node_and_flags(TALLOC_CTX *mem_ctx,
+ struct ctdb_node_and_flags *p);
+void verify_ctdb_node_and_flags(struct ctdb_node_and_flags *p1,
+ struct ctdb_node_and_flags *p2);
+
+void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p);
+void verify_ctdb_node_map(struct ctdb_node_map *p1, struct ctdb_node_map *p2);
+
+void fill_ctdb_script(TALLOC_CTX *mem_ctx, struct ctdb_script *p);
+void verify_ctdb_script(struct ctdb_script *p1, struct ctdb_script *p2);
+
+void fill_ctdb_script_list(TALLOC_CTX *mem_ctx, struct ctdb_script_list *p);
+void verify_ctdb_script_list(struct ctdb_script_list *p1,
+ struct ctdb_script_list *p2);
+
+void fill_ctdb_ban_state(TALLOC_CTX *mem_ctx, struct ctdb_ban_state *p);
+void verify_ctdb_ban_state(struct ctdb_ban_state *p1,
+ struct ctdb_ban_state *p2);
+
+void fill_ctdb_notify_data(TALLOC_CTX *mem_ctx, struct ctdb_notify_data *p);
+void verify_ctdb_notify_data(struct ctdb_notify_data *p1,
+ struct ctdb_notify_data *p2);
+
+void fill_ctdb_iface(TALLOC_CTX *mem_ctx, struct ctdb_iface *p);
+void verify_ctdb_iface(struct ctdb_iface *p1, struct ctdb_iface *p2);
+
+void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx, struct ctdb_iface_list *p);
+void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
+ struct ctdb_iface_list *p2);
+
+void fill_ctdb_public_ip_info(TALLOC_CTX *mem_ctx,
+ struct ctdb_public_ip_info *p);
+void verify_ctdb_public_ip_info(struct ctdb_public_ip_info *p1,
+ struct ctdb_public_ip_info *p2);
+
+void fill_ctdb_statistics_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_statistics_list *p);
+void verify_ctdb_statistics_list(struct ctdb_statistics_list *p1,
+ struct ctdb_statistics_list *p2);
+
+void fill_ctdb_key_data(TALLOC_CTX *mem_ctx, struct ctdb_key_data *p);
+void verify_ctdb_key_data(struct ctdb_key_data *p1, struct ctdb_key_data *p2);
+
+void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
+ struct ctdb_db_statistics *p);
+void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
+ struct ctdb_db_statistics *p2);
+
+void fill_ctdb_election_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_election_message *p);
+void verify_ctdb_election_message(struct ctdb_election_message *p1,
+ struct ctdb_election_message *p2);
+
+void fill_ctdb_srvid_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_srvid_message *p);
+void verify_ctdb_srvid_message(struct ctdb_srvid_message *p1,
+ struct ctdb_srvid_message *p2);
+
+void fill_ctdb_disable_message(TALLOC_CTX *mem_ctx,
+ struct ctdb_disable_message *p);
+void verify_ctdb_disable_message(struct ctdb_disable_message *p1,
+ struct ctdb_disable_message *p2);
+
+void fill_ctdb_server_id(TALLOC_CTX *mem_ctx, struct ctdb_server_id *p);
+void verify_ctdb_server_id(struct ctdb_server_id *p1,
+ struct ctdb_server_id *p2);
+
+void fill_ctdb_g_lock(TALLOC_CTX *mem_ctx, struct ctdb_g_lock *p);
+void verify_ctdb_g_lock(struct ctdb_g_lock *p1, struct ctdb_g_lock *p2);
+
+void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx, struct ctdb_g_lock_list *p);
+void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
+ struct ctdb_g_lock_list *p2);
+
+#endif /* __CTDB_PROTOCOL_COMMON_H__ */
/*
- protocol tests
+ protocol tests - ctdb protocol
- Copyright (C) Amitay Isaacs 2015
+ Copyright (C) Amitay Isaacs 2017
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
#include <assert.h>
-#define PROTOCOL_TEST
-
-#include "protocol_types_test.c"
-
-
-#define GENERATION 0xabcdef12
-#define OPERATION CTDB_REQ_KEEPALIVE
-#define REQID 0x34567890
-#define SRCNODE 7
-#define DESTNODE 13
+#include "tests/src/protocol_common.h"
+#include "tests/src/protocol_common_ctdb.h"
/*
* Functions to fill and verify protocol structures
*/
-static void verify_ctdb_req_header(struct ctdb_req_header *h,
- struct ctdb_req_header *h2)
+void verify_ctdb_req_header(struct ctdb_req_header *h,
+ struct ctdb_req_header *h2)
{
- verify_buffer(h, h2, ctdb_req_header_len(h));
+ verify_buffer(h, h2, sizeof(struct ctdb_req_header));
}
-static void fill_ctdb_req_call(TALLOC_CTX *mem_ctx,
- struct ctdb_req_call *c)
+void fill_ctdb_req_call(TALLOC_CTX *mem_ctx, struct ctdb_req_call *c)
{
c->flags = rand32();
c->db_id = rand32();
fill_tdb_data(mem_ctx, &c->calldata);
}
-static void verify_ctdb_req_call(struct ctdb_req_call *c,
- struct ctdb_req_call *c2)
+void verify_ctdb_req_call(struct ctdb_req_call *c, struct ctdb_req_call *c2)
{
assert(c->flags == c2->flags);
assert(c->db_id == c2->db_id);
verify_tdb_data(&c->calldata, &c2->calldata);
}
-static void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx,
- struct ctdb_reply_call *c)
+void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx, struct ctdb_reply_call *c)
{
c->status = rand32();
fill_tdb_data(mem_ctx, &c->data);
}
-static void verify_ctdb_reply_call(struct ctdb_reply_call *c,
- struct ctdb_reply_call *c2)
+void verify_ctdb_reply_call(struct ctdb_reply_call *c,
+ struct ctdb_reply_call *c2)
{
assert(c->status == c2->status);
verify_tdb_data(&c->data, &c2->data);
}
-static void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx,
- struct ctdb_reply_error *c)
+void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx, struct ctdb_reply_error *c)
{
c->status = rand32();
fill_tdb_data(mem_ctx, &c->msg);
}
-static void verify_ctdb_reply_error(struct ctdb_reply_error *c,
- struct ctdb_reply_error *c2)
+void verify_ctdb_reply_error(struct ctdb_reply_error *c,
+ struct ctdb_reply_error *c2)
{
assert(c->status == c2->status);
verify_tdb_data(&c->msg, &c2->msg);
}
-static void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx,
- struct ctdb_req_dmaster *c)
+void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx, struct ctdb_req_dmaster *c)
{
c->db_id = rand32();
c->rsn = rand64();
fill_tdb_data(mem_ctx, &c->data);
}
-static void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
- struct ctdb_req_dmaster *c2)
+void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
+ struct ctdb_req_dmaster *c2)
{
assert(c->db_id == c2->db_id);
assert(c->rsn == c2->rsn);
verify_tdb_data(&c->data, &c2->data);
}
-static void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
- struct ctdb_reply_dmaster *c)
+void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_dmaster *c)
{
c->db_id = rand32();
c->rsn = rand64();
fill_tdb_data(mem_ctx, &c->data);
}
-static void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
- struct ctdb_reply_dmaster *c2)
+void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
+ struct ctdb_reply_dmaster *c2)
{
assert(c->db_id == c2->db_id);
assert(c->rsn == c2->rsn);
verify_tdb_data(&c->data, &c2->data);
}
-static void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
- struct ctdb_req_control_data *cd,
- uint32_t opcode)
+void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_req_control_data *cd,
+ uint32_t opcode)
{
cd->opcode = opcode;
switch (opcode) {
}
}
-static void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
- struct ctdb_req_control_data *cd2)
+void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
+ struct ctdb_req_control_data *cd2)
{
assert(cd->opcode == cd2->opcode);
}
}
-static void fill_ctdb_req_control(TALLOC_CTX *mem_ctx,
- struct ctdb_req_control *c,
- uint32_t opcode)
+void fill_ctdb_req_control(TALLOC_CTX *mem_ctx, struct ctdb_req_control *c,
+ uint32_t opcode)
{
c->opcode = opcode;
c->pad = rand32();
fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode);
}
-static void verify_ctdb_req_control(struct ctdb_req_control *c,
- struct ctdb_req_control *c2)
+void verify_ctdb_req_control(struct ctdb_req_control *c,
+ struct ctdb_req_control *c2)
{
assert(c->opcode == c2->opcode);
assert(c->pad == c2->pad);
verify_ctdb_req_control_data(&c->rdata, &c2->rdata);
}
-static void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
- struct ctdb_reply_control_data *cd,
- uint32_t opcode)
+void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_control_data *cd,
+ uint32_t opcode)
{
cd->opcode = opcode;
}
}
-static void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
- struct ctdb_reply_control_data *cd2)
+void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
+ struct ctdb_reply_control_data *cd2)
{
assert(cd->opcode == cd2->opcode);
}
}
-static void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
- struct ctdb_reply_control *c,
- uint32_t opcode)
+void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_control *c, uint32_t opcode)
{
c->status = -rand_int(2);
if (c->status == 0) {
}
}
-static void verify_ctdb_reply_control(struct ctdb_reply_control *c,
- struct ctdb_reply_control *c2)
+void verify_ctdb_reply_control(struct ctdb_reply_control *c,
+ struct ctdb_reply_control *c2)
{
assert(c->status == c2->status);
verify_ctdb_string(c->errmsg, c2->errmsg);
}
}
-static void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
- struct ctdb_req_message_data *c)
+void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_req_message_data *c)
{
c->srvid = rand64();
fill_tdb_data(mem_ctx, &c->data);
}
-static void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
- struct ctdb_req_message_data *c2)
+void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
+ struct ctdb_req_message_data *c2)
{
assert(c->srvid == c2->srvid);
verify_tdb_data(&c->data, &c2->data);
}
-
-/*
- * Functions to fill and verify eventd protocol structures
- */
-
-static void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
- struct ctdb_event_request_data *r,
- uint32_t command)
-{
- r->command = command;
-
- switch (command) {
- case CTDB_EVENT_COMMAND_RUN:
- r->data.run = talloc(mem_ctx, struct ctdb_event_request_run);
- assert(r->data.run != NULL);
-
- fill_ctdb_event_request_run(mem_ctx, r->data.run);
- break;
-
- case CTDB_EVENT_COMMAND_STATUS:
- r->data.status = talloc(mem_ctx,
- struct ctdb_event_request_status);
- assert(r->data.status != NULL);
-
- fill_ctdb_event_request_status(mem_ctx, r->data.status);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_LIST:
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
- r->data.script_enable = talloc(mem_ctx,
- struct ctdb_event_request_script_enable);
- assert(r->data.script_enable != NULL);
-
- fill_ctdb_event_request_script_enable(mem_ctx,
- r->data.script_enable);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
- r->data.script_disable = talloc(mem_ctx,
- struct ctdb_event_request_script_disable);
- assert(r->data.script_disable != NULL);
-
- fill_ctdb_event_request_script_disable(mem_ctx,
- r->data.script_disable);
- break;
- }
-}
-
-static void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
- struct ctdb_event_request_data *r2)
-{
- assert(r->command == r2->command);
-
- switch (r->command) {
- case CTDB_EVENT_COMMAND_RUN:
- verify_ctdb_event_request_run(r->data.run, r2->data.run);
- break;
-
- case CTDB_EVENT_COMMAND_STATUS:
- verify_ctdb_event_request_status(r->data.status,
- r2->data.status);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_LIST:
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
- verify_ctdb_event_request_script_enable(r->data.script_enable,
- r2->data.script_enable);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
- verify_ctdb_event_request_script_disable(r->data.script_disable,
- r2->data.script_disable);
- break;
- }
-}
-
-static void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
- struct ctdb_event_reply_data *r,
- uint32_t command)
-{
- r->command = command;
- r->result = rand32i();
-
- switch (command) {
- case CTDB_EVENT_COMMAND_STATUS:
- r->data.status = talloc(mem_ctx,
- struct ctdb_event_reply_status);
- assert(r->data.status != NULL);
-
- fill_ctdb_event_reply_status(mem_ctx, r->data.status);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_LIST:
- r->data.script_list = talloc(mem_ctx,
- struct ctdb_event_reply_script_list);
- assert(r->data.script_list != NULL);
-
- fill_ctdb_event_reply_script_list(mem_ctx,
- r->data.script_list);
- break;
- }
-}
-
-static void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
- struct ctdb_event_reply_data *r2)
-{
- assert(r->command == r2->command);
- assert(r->result == r2->result);
-
- switch (r->command) {
- case CTDB_EVENT_COMMAND_RUN:
- break;
-
- case CTDB_EVENT_COMMAND_STATUS:
- verify_ctdb_event_reply_status(r->data.status,
- r2->data.status);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_LIST:
- verify_ctdb_event_reply_script_list(r->data.script_list,
- r2->data.script_list);
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
- break;
-
- case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
- break;
- }
-}
-
-static void verify_ctdb_event_header(struct ctdb_event_header *h,
- struct ctdb_event_header *h2)
-{
- verify_buffer(h, h2, ctdb_event_header_len(h));
-}
-
-static void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
- struct ctdb_event_request *r,
- uint32_t command)
-{
- ctdb_event_header_fill(&r->header, rand());
- fill_ctdb_event_request_data(mem_ctx, &r->rdata, command);
-}
-
-static void verify_ctdb_event_request(struct ctdb_event_request *r,
- struct ctdb_event_request *r2)
-{
- verify_ctdb_event_header(&r->header, &r2->header);
- verify_ctdb_event_request_data(&r->rdata, &r2->rdata);
-}
-
-static void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx,
- struct ctdb_event_reply *r,
- uint32_t command)
-{
- ctdb_event_header_fill(&r->header, rand());
- fill_ctdb_event_reply_data(mem_ctx, &r->rdata, command);
-}
-
-static void verify_ctdb_event_reply(struct ctdb_event_reply *r,
- struct ctdb_event_reply *r2)
-{
- verify_ctdb_event_header(&r->header, &r2->header);
- verify_ctdb_event_reply_data(&r->rdata, &r2->rdata);
-}
-
-/*
- * Functions to test marshalling
- */
-
-static void test_ctdb_req_header(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t pkt_len;
- struct ctdb_req_header h, h2;
- int ret;
-
- printf("ctdb_req_header\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, OPERATION, DESTNODE, SRCNODE,
- REQID);
-
- ret = ctdb_allocate_pkt(mem_ctx, ctdb_req_header_len(&h),
- &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= ctdb_req_header_len(&h));
-
- ctdb_req_header_push(&h, pkt);
-
- ret = ctdb_req_header_pull(pkt, pkt_len, &h2);
- assert(ret == 0);
-
- verify_ctdb_req_header(&h, &h2);
-
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_req_call(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_req_call c, c2;
-
- printf("ctdb_req_call\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CALL,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_req_call(mem_ctx, &c);
- datalen = ctdb_req_call_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_req_call_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_req_call_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_req_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_req_call(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_reply_call(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_reply_call c, c2;
-
- printf("ctdb_reply_call\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CALL,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_reply_call(mem_ctx, &c);
- datalen = ctdb_reply_call_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_reply_call_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_reply_call_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_reply_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_reply_call(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_reply_error(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_reply_error c, c2;
-
- printf("ctdb_reply_error\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_ERROR,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_reply_error(mem_ctx, &c);
- datalen = ctdb_reply_error_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_reply_error_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_reply_error_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_reply_error_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_reply_error(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_req_dmaster(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_req_dmaster c, c2;
-
- printf("ctdb_req_dmaster\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_DMASTER,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_req_dmaster(mem_ctx, &c);
- datalen = ctdb_req_dmaster_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_req_dmaster_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_req_dmaster_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_req_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_req_dmaster(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_reply_dmaster(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_reply_dmaster c, c2;
-
- printf("ctdb_reply_dmaster\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_DMASTER,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_reply_dmaster(mem_ctx, &c);
- datalen = ctdb_reply_dmaster_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_reply_dmaster_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_reply_dmaster_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_reply_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_reply_dmaster(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-#define NUM_CONTROLS 151
-
-static void test_ctdb_req_control_data(void)
-{
- TALLOC_CTX *mem_ctx;
- size_t buflen;
- int ret;
- struct ctdb_req_control_data cd, cd2;
- uint32_t opcode;
-
- printf("ctdb_req_control_data\n");
- fflush(stdout);
-
- for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", opcode);
- fflush(stdout);
- fill_ctdb_req_control_data(mem_ctx, &cd, opcode);
- buflen = ctdb_req_control_data_len(&cd);
- ctdb_req_control_data_push(&cd, BUFFER);
- ret = ctdb_req_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
- assert(ret == 0);
- verify_ctdb_req_control_data(&cd, &cd2);
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_reply_control_data(void)
-{
- TALLOC_CTX *mem_ctx;
- size_t buflen;
- int ret;
- struct ctdb_reply_control_data cd, cd2;
- uint32_t opcode;
-
- printf("ctdb_reply_control_data\n");
- fflush(stdout);
-
- for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", opcode);
- fflush(stdout);
- fill_ctdb_reply_control_data(mem_ctx, &cd, opcode);
- buflen = ctdb_reply_control_data_len(&cd);
- ctdb_reply_control_data_push(&cd, BUFFER);
- ret = ctdb_reply_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
- assert(ret == 0);
- verify_ctdb_reply_control_data(&cd, &cd2);
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_req_control(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_req_control c, c2;
- uint32_t opcode;
-
- printf("ctdb_req_control\n");
- fflush(stdout);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CONTROL,
- DESTNODE, SRCNODE, REQID);
-
- for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", opcode);
- fflush(stdout);
- fill_ctdb_req_control(mem_ctx, &c, opcode);
- datalen = ctdb_req_control_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_req_control_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_req_control_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_req_control_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_req_control(&c, &c2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_reply_control(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_reply_control c, c2;
- uint32_t opcode;
-
- printf("ctdb_reply_control\n");
- fflush(stdout);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CONTROL,
- DESTNODE, SRCNODE, REQID);
-
- for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", opcode);
- fflush(stdout);
- fill_ctdb_reply_control(mem_ctx, &c, opcode);
- datalen = ctdb_reply_control_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_reply_control_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_reply_control_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_reply_control_pull(pkt, pkt_len, opcode, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_reply_control(&c, &c2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_req_message_data(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *pkt;
- size_t datalen, pkt_len, len;
- int ret;
- struct ctdb_req_header h, h2;
- struct ctdb_req_message_data c, c2;
-
- printf("ctdb_req_message\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_MESSAGE,
- DESTNODE, SRCNODE, REQID);
-
- fill_ctdb_req_message_data(mem_ctx, &c);
- datalen = ctdb_req_message_data_len(&h, &c);
- ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
- assert(ret == 0);
- assert(pkt != NULL);
- assert(pkt_len >= datalen);
- len = 0;
- ret = ctdb_req_message_data_push(&h, &c, pkt, &len);
- assert(ret == EMSGSIZE);
- assert(len == datalen);
- ret = ctdb_req_message_data_push(&h, &c, pkt, &pkt_len);
- assert(ret == 0);
- ret = ctdb_req_message_data_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
- assert(ret == 0);
- verify_ctdb_req_header(&h, &h2);
- assert(h2.length == pkt_len);
- verify_ctdb_req_message_data(&c, &c2);
-
- talloc_free(mem_ctx);
-}
-
-/*
- * Functions to test eventd protocol marshalling
- */
-
-static void test_ctdb_event_header(void)
-{
- TALLOC_CTX *mem_ctx;
- size_t buflen;
- struct ctdb_event_header h, h2;
- int ret;
-
- printf("ctdb_event_header\n");
- fflush(stdout);
-
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- ctdb_event_header_fill(&h, REQID);
-
- buflen = ctdb_event_header_len(&h);
- ctdb_event_header_push(&h, BUFFER);
- ret = ctdb_event_header_pull(BUFFER, buflen, mem_ctx, &h2);
- assert(ret == 0);
-
- verify_ctdb_event_header(&h, &h2);
-
- talloc_free(mem_ctx);
-}
-
-#define NUM_COMMANDS 5
-
-static void test_ctdb_event_request_data(void)
-{
- TALLOC_CTX *mem_ctx;
- size_t buflen;
- struct ctdb_event_request_data rd, rd2;
- uint32_t command;
- int ret;
-
- printf("ctdb_event_request_data\n");
- fflush(stdout);
-
- for (command=1; command<=NUM_COMMANDS; command++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", command);
- fflush(stdout);
- fill_ctdb_event_request_data(mem_ctx, &rd, command);
- buflen = ctdb_event_request_data_len(&rd);
- ctdb_event_request_data_push(&rd, BUFFER);
- ret = ctdb_event_request_data_pull(BUFFER, buflen, mem_ctx, &rd2);
- assert(ret == 0);
- verify_ctdb_event_request_data(&rd, &rd2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_event_reply_data(void)
-{
- TALLOC_CTX *mem_ctx;
- size_t buflen;
- struct ctdb_event_reply_data rd, rd2;
- uint32_t command;
- int ret;
-
- printf("ctdb_event_reply_data\n");
- fflush(stdout);
-
- for (command=1; command<=NUM_COMMANDS; command++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", command);
- fflush(stdout);
- fill_ctdb_event_reply_data(mem_ctx, &rd, command);
- buflen = ctdb_event_reply_data_len(&rd);
- ctdb_event_reply_data_push(&rd, BUFFER);
- ret = ctdb_event_reply_data_pull(BUFFER, buflen, mem_ctx, &rd2);
- assert(ret == 0);
- verify_ctdb_event_reply_data(&rd, &rd2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_event_request(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *buf;
- size_t len, buflen;
- int ret;
- struct ctdb_event_request r, r2;
- uint32_t command;
-
- printf("ctdb_event_request\n");
- fflush(stdout);
-
- for (command=1; command<=NUM_COMMANDS; command++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", command);
- fflush(stdout);
- fill_ctdb_event_request(mem_ctx, &r, command);
- buflen = ctdb_event_request_len(&r);
- buf = talloc_size(mem_ctx, buflen);
- assert(buf != NULL);
- len = 0;
- ret = ctdb_event_request_push(&r, buf, &len);
- assert(ret == EMSGSIZE);
- assert(len == buflen);
- ret = ctdb_event_request_push(&r, buf, &buflen);
- assert(ret == 0);
- ret = ctdb_event_request_pull(buf, buflen, mem_ctx, &r2);
- assert(ret == 0);
- assert(r2.header.length == buflen);
- verify_ctdb_event_request(&r, &r2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-static void test_ctdb_event_reply(void)
-{
- TALLOC_CTX *mem_ctx;
- uint8_t *buf;
- size_t len, buflen;
- int ret;
- struct ctdb_event_reply r, r2;
- uint32_t command;
-
- printf("ctdb_event_reply\n");
- fflush(stdout);
-
- for (command=1; command<=NUM_COMMANDS; command++) {
- mem_ctx = talloc_new(NULL);
- assert(mem_ctx != NULL);
-
- printf("%u.. ", command);
- fflush(stdout);
- fill_ctdb_event_reply(mem_ctx, &r, command);
- buflen = ctdb_event_reply_len(&r);
- buf = talloc_size(mem_ctx, buflen);
- assert(buf != NULL);
- len = 0;
- ret = ctdb_event_reply_push(&r, buf, &len);
- assert(ret == EMSGSIZE);
- assert(len == buflen);
- ret = ctdb_event_reply_push(&r, buf, &buflen);
- assert(ret == 0);
- ret = ctdb_event_reply_pull(buf, buflen, mem_ctx, &r2);
- assert(ret == 0);
- assert(r2.header.length == buflen);
- verify_ctdb_event_reply(&r, &r2);
-
- talloc_free(mem_ctx);
- }
-
- printf("\n");
- fflush(stdout);
-}
-
-int main(int argc, char *argv[])
-{
- if (argc == 2) {
- int seed = atoi(argv[1]);
- srandom(seed);
- }
-
- test_ctdb_req_header();
-
- test_ctdb_req_call();
- test_ctdb_reply_call();
- test_ctdb_reply_error();
- test_ctdb_req_dmaster();
- test_ctdb_reply_dmaster();
-
- test_ctdb_req_control_data();
- test_ctdb_reply_control_data();
-
- test_ctdb_req_control();
- test_ctdb_reply_control();
-
- test_ctdb_req_message_data();
-
- test_ctdb_event_header();
-
- test_ctdb_event_request_data();
- test_ctdb_event_reply_data();
- test_ctdb_event_request();
- test_ctdb_event_reply();
-
- return 0;
-}
--- /dev/null
+/*
+ protocol tests - ctdb protocol
+
+ Copyright (C) Amitay Isaacs 2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __CTDB_PROTOCOL_COMMON_CTDB_H__
+#define __CTDB_PROTOCOL_COMMON_CTDB_H__
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <talloc.h>
+#include <tdb.h>
+
+#include "protocol/protocol.h"
+
+void verify_ctdb_req_header(struct ctdb_req_header *h,
+ struct ctdb_req_header *h2);
+
+void fill_ctdb_req_call(TALLOC_CTX *mem_ctx, struct ctdb_req_call *c);
+void verify_ctdb_req_call(struct ctdb_req_call *c, struct ctdb_req_call *c2);
+
+void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx, struct ctdb_reply_call *c);
+void verify_ctdb_reply_call(struct ctdb_reply_call *c,
+ struct ctdb_reply_call *c2);
+
+void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx, struct ctdb_reply_error *c);
+void verify_ctdb_reply_error(struct ctdb_reply_error *c,
+ struct ctdb_reply_error *c2);
+
+void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx, struct ctdb_req_dmaster *c);
+void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
+ struct ctdb_req_dmaster *c2);
+
+void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_dmaster *c);
+void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
+ struct ctdb_reply_dmaster *c2);
+
+void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_req_control_data *cd,
+ uint32_t opcode);
+void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
+ struct ctdb_req_control_data *cd2);
+
+void fill_ctdb_req_control(TALLOC_CTX *mem_ctx, struct ctdb_req_control *c,
+ uint32_t opcode);
+void verify_ctdb_req_control(struct ctdb_req_control *c,
+ struct ctdb_req_control *c2);
+
+void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_control_data *cd,
+ uint32_t opcode);
+void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
+ struct ctdb_reply_control_data *cd2);
+
+void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
+ struct ctdb_reply_control *c, uint32_t opcode);
+void verify_ctdb_reply_control(struct ctdb_reply_control *c,
+ struct ctdb_reply_control *c2);
+
+void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_req_message_data *c);
+void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
+ struct ctdb_req_message_data *c2);
+
+#endif /* __CTDB_PROTOCOL_COMMON_CTDB_H__ */
--- /dev/null
+/*
+ protocol tests - eventd protocol
+
+ Copyright (C) Amitay Isaacs 2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <assert.h>
+
+#include "tests/src/protocol_common.h"
+#include "tests/src/protocol_common_event.h"
+
+/*
+ * Functions to fill and verify eventd protocol structures
+ */
+
+void fill_ctdb_event_request_run(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_run *p)
+{
+ p->event = rand_int(CTDB_EVENT_MAX);
+ p->timeout = rand();
+ fill_ctdb_string(mem_ctx, &p->arg_str);
+}
+
+void verify_ctdb_event_request_run(struct ctdb_event_request_run *p1,
+ struct ctdb_event_request_run *p2)
+{
+ assert(p1->event == p2->event);
+ assert(p1->timeout == p2->timeout);
+ verify_ctdb_string(p1->arg_str, p2->arg_str);
+}
+
+void fill_ctdb_event_request_status(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_status *p)
+{
+ p->event = rand_int(CTDB_EVENT_MAX);
+ p->state = rand_int(3) + 1;
+}
+
+void verify_ctdb_event_request_status(struct ctdb_event_request_status *p1,
+ struct ctdb_event_request_status *p2)
+{
+ assert(p1->event == p2->event);
+ assert(p1->state == p2->state);
+}
+
+void fill_ctdb_event_request_script_enable(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_script_enable *p)
+{
+ fill_ctdb_string(mem_ctx, &p->script_name);
+}
+
+void verify_ctdb_event_request_script_enable(
+ struct ctdb_event_request_script_enable *p1,
+ struct ctdb_event_request_script_enable *p2)
+{
+ verify_ctdb_string(p1->script_name, p2->script_name);
+}
+
+void fill_ctdb_event_request_script_disable(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_script_disable *p)
+{
+ fill_ctdb_string(mem_ctx, &p->script_name);
+}
+
+void verify_ctdb_event_request_script_disable(
+ struct ctdb_event_request_script_disable *p1,
+ struct ctdb_event_request_script_disable *p2)
+{
+ verify_ctdb_string(p1->script_name, p2->script_name);
+}
+
+void fill_ctdb_event_reply_status(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_status *p)
+{
+ if (rand_int(2) == 0) {
+ p->status = 0;
+ p->script_list = talloc(mem_ctx, struct ctdb_script_list);
+ assert(p->script_list != NULL);
+ fill_ctdb_script_list(mem_ctx, p->script_list);
+ } else {
+ p->status = rand32i();
+ p->script_list = NULL;
+ }
+}
+
+void verify_ctdb_event_reply_status(struct ctdb_event_reply_status *p1,
+ struct ctdb_event_reply_status *p2)
+{
+ assert(p1->status == p2->status);
+ if (p1->script_list == NULL) {
+ assert(p1->script_list == p2->script_list);
+ } else {
+ verify_ctdb_script_list(p1->script_list, p2->script_list);
+ }
+}
+
+void fill_ctdb_event_reply_script_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_script_list *p)
+{
+ p->script_list = talloc(mem_ctx, struct ctdb_script_list);
+ assert(p->script_list != NULL);
+
+ fill_ctdb_script_list(mem_ctx, p->script_list);
+}
+
+void verify_ctdb_event_reply_script_list(
+ struct ctdb_event_reply_script_list *p1,
+ struct ctdb_event_reply_script_list *p2)
+{
+ verify_ctdb_script_list(p1->script_list, p2->script_list);
+}
+
+void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_data *r,
+ uint32_t command)
+{
+ r->command = command;
+
+ switch (command) {
+ case CTDB_EVENT_COMMAND_RUN:
+ r->data.run = talloc(mem_ctx, struct ctdb_event_request_run);
+ assert(r->data.run != NULL);
+
+ fill_ctdb_event_request_run(mem_ctx, r->data.run);
+ break;
+
+ case CTDB_EVENT_COMMAND_STATUS:
+ r->data.status = talloc(mem_ctx,
+ struct ctdb_event_request_status);
+ assert(r->data.status != NULL);
+
+ fill_ctdb_event_request_status(mem_ctx, r->data.status);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_LIST:
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
+ r->data.script_enable = talloc(mem_ctx,
+ struct ctdb_event_request_script_enable);
+ assert(r->data.script_enable != NULL);
+
+ fill_ctdb_event_request_script_enable(mem_ctx,
+ r->data.script_enable);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
+ r->data.script_disable = talloc(mem_ctx,
+ struct ctdb_event_request_script_disable);
+ assert(r->data.script_disable != NULL);
+
+ fill_ctdb_event_request_script_disable(mem_ctx,
+ r->data.script_disable);
+ break;
+ }
+}
+
+void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
+ struct ctdb_event_request_data *r2)
+{
+ assert(r->command == r2->command);
+
+ switch (r->command) {
+ case CTDB_EVENT_COMMAND_RUN:
+ verify_ctdb_event_request_run(r->data.run, r2->data.run);
+ break;
+
+ case CTDB_EVENT_COMMAND_STATUS:
+ verify_ctdb_event_request_status(r->data.status,
+ r2->data.status);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_LIST:
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
+ verify_ctdb_event_request_script_enable(r->data.script_enable,
+ r2->data.script_enable);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
+ verify_ctdb_event_request_script_disable(r->data.script_disable,
+ r2->data.script_disable);
+ break;
+ }
+}
+
+void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_data *r,
+ uint32_t command)
+{
+ r->command = command;
+ r->result = rand32i();
+
+ switch (command) {
+ case CTDB_EVENT_COMMAND_STATUS:
+ r->data.status = talloc(mem_ctx,
+ struct ctdb_event_reply_status);
+ assert(r->data.status != NULL);
+
+ fill_ctdb_event_reply_status(mem_ctx, r->data.status);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_LIST:
+ r->data.script_list = talloc(mem_ctx,
+ struct ctdb_event_reply_script_list);
+ assert(r->data.script_list != NULL);
+
+ fill_ctdb_event_reply_script_list(mem_ctx,
+ r->data.script_list);
+ break;
+ }
+}
+
+void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
+ struct ctdb_event_reply_data *r2)
+{
+ assert(r->command == r2->command);
+ assert(r->result == r2->result);
+
+ switch (r->command) {
+ case CTDB_EVENT_COMMAND_RUN:
+ break;
+
+ case CTDB_EVENT_COMMAND_STATUS:
+ verify_ctdb_event_reply_status(r->data.status,
+ r2->data.status);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_LIST:
+ verify_ctdb_event_reply_script_list(r->data.script_list,
+ r2->data.script_list);
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
+ break;
+
+ case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
+ break;
+ }
+}
+
+void fill_ctdb_event_header(struct ctdb_event_header *h)
+{
+ h->length = rand32();
+ h->reqid = rand32();
+}
+
+void verify_ctdb_event_header(struct ctdb_event_header *h,
+ struct ctdb_event_header *h2)
+{
+ assert(h->length == h2->length);
+ assert(h->reqid == h2->reqid);
+}
+
+void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request *r, uint32_t command)
+{
+ fill_ctdb_event_header(&r->header);
+ fill_ctdb_event_request_data(mem_ctx, &r->rdata, command);
+}
+
+void verify_ctdb_event_request(struct ctdb_event_request *r,
+ struct ctdb_event_request *r2)
+{
+ verify_ctdb_event_header(&r->header, &r2->header);
+ verify_ctdb_event_request_data(&r->rdata, &r2->rdata);
+}
+
+void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx, struct ctdb_event_reply *r,
+ uint32_t command)
+{
+ fill_ctdb_event_header(&r->header);
+ fill_ctdb_event_reply_data(mem_ctx, &r->rdata, command);
+}
+
+void verify_ctdb_event_reply(struct ctdb_event_reply *r,
+ struct ctdb_event_reply *r2)
+{
+ verify_ctdb_event_header(&r->header, &r2->header);
+ verify_ctdb_event_reply_data(&r->rdata, &r2->rdata);
+}
--- /dev/null
+/*
+ protocol tests - eventd protocol
+
+ Copyright (C) Amitay Isaacs 2017
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __CTDB_PROTOCOL_COMMON_EVENT_H__
+#define __CTDB_PROTOCOL_COMMON_EVENT_H__
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <talloc.h>
+#include <tdb.h>
+
+#include "protocol/protocol.h"
+
+void fill_ctdb_event_request_run(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_run *p);
+void verify_ctdb_event_request_run(struct ctdb_event_request_run *p1,
+ struct ctdb_event_request_run *p2);
+
+void fill_ctdb_event_request_status(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_status *p);
+void verify_ctdb_event_request_status(struct ctdb_event_request_status *p1,
+ struct ctdb_event_request_status *p2);
+
+void fill_ctdb_event_request_script_enable(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_script_enable *p);
+void verify_ctdb_event_request_script_enable(
+ struct ctdb_event_request_script_enable *p1,
+ struct ctdb_event_request_script_enable *p2);
+
+void fill_ctdb_event_request_script_disable(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_script_disable *p);
+void verify_ctdb_event_request_script_disable(
+ struct ctdb_event_request_script_disable *p1,
+ struct ctdb_event_request_script_disable *p2);
+
+void fill_ctdb_event_reply_status(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_status *p);
+void verify_ctdb_event_reply_status(struct ctdb_event_reply_status *p1,
+ struct ctdb_event_reply_status *p2);
+
+void fill_ctdb_event_reply_script_list(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_script_list *p);
+void verify_ctdb_event_reply_script_list(
+ struct ctdb_event_reply_script_list *p1,
+ struct ctdb_event_reply_script_list *p2);
+
+void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request_data *r,
+ uint32_t command);
+void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
+ struct ctdb_event_request_data *r2);
+
+void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_reply_data *r,
+ uint32_t command);
+void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
+ struct ctdb_event_reply_data *r2);
+
+void fill_ctdb_event_header(struct ctdb_event_header *h);
+void verify_ctdb_event_header(struct ctdb_event_header *h,
+ struct ctdb_event_header *h2);
+
+void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
+ struct ctdb_event_request *r, uint32_t command);
+void verify_ctdb_event_request(struct ctdb_event_request *r,
+ struct ctdb_event_request *r2);
+
+void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx, struct ctdb_event_reply *r,
+ uint32_t command);
+void verify_ctdb_event_reply(struct ctdb_event_reply *r,
+ struct ctdb_event_reply *r2);
+
+#endif /* __CTDB_PROTOCOL_COMMON_EVENT_H__ */
--- /dev/null
+/*
+ protocol tests
+
+ Copyright (C) Amitay Isaacs 2015
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <assert.h>
+
+#include "protocol/protocol_basic.c"
+#include "protocol/protocol_types.c"
+#include "protocol/protocol_header.c"
+#include "protocol/protocol_call.c"
+#include "protocol/protocol_control.c"
+#include "protocol/protocol_message.c"
+#include "protocol/protocol_packet.c"
+
+#include "tests/src/protocol_common.h"
+#include "tests/src/protocol_common_ctdb.h"
+
+
+#define GENERATION 0xabcdef12
+#define OPERATION CTDB_REQ_KEEPALIVE
+#define REQID 0x34567890
+#define SRCNODE 7
+#define DESTNODE 13
+
+/*
+ * Functions to test marshalling
+ */
+
+static void test_ctdb_req_header(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t pkt_len;
+ struct ctdb_req_header h, h2;
+ int ret;
+
+ printf("ctdb_req_header\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, OPERATION, DESTNODE, SRCNODE,
+ REQID);
+
+ ret = ctdb_allocate_pkt(mem_ctx, ctdb_req_header_len(&h),
+ &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= ctdb_req_header_len(&h));
+
+ ctdb_req_header_push(&h, pkt);
+
+ ret = ctdb_req_header_pull(pkt, pkt_len, &h2);
+ assert(ret == 0);
+
+ verify_ctdb_req_header(&h, &h2);
+
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_req_call(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_req_call c, c2;
+
+ printf("ctdb_req_call\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CALL,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_req_call(mem_ctx, &c);
+ datalen = ctdb_req_call_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_req_call_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_req_call_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_req_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_req_call(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_reply_call(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_reply_call c, c2;
+
+ printf("ctdb_reply_call\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CALL,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_reply_call(mem_ctx, &c);
+ datalen = ctdb_reply_call_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_reply_call_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_reply_call_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_reply_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_reply_call(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_reply_error(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_reply_error c, c2;
+
+ printf("ctdb_reply_error\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_ERROR,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_reply_error(mem_ctx, &c);
+ datalen = ctdb_reply_error_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_reply_error_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_reply_error_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_reply_error_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_reply_error(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_req_dmaster(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_req_dmaster c, c2;
+
+ printf("ctdb_req_dmaster\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_DMASTER,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_req_dmaster(mem_ctx, &c);
+ datalen = ctdb_req_dmaster_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_req_dmaster_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_req_dmaster_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_req_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_req_dmaster(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+static void test_ctdb_reply_dmaster(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_reply_dmaster c, c2;
+
+ printf("ctdb_reply_dmaster\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_DMASTER,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_reply_dmaster(mem_ctx, &c);
+ datalen = ctdb_reply_dmaster_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_reply_dmaster_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_reply_dmaster_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_reply_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_reply_dmaster(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+#define NUM_CONTROLS 151
+
+static void test_ctdb_req_control_data(void)
+{
+ TALLOC_CTX *mem_ctx;
+ size_t buflen;
+ int ret;
+ struct ctdb_req_control_data cd, cd2;
+ uint32_t opcode;
+
+ printf("ctdb_req_control_data\n");
+ fflush(stdout);
+
+ for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", opcode);
+ fflush(stdout);
+ fill_ctdb_req_control_data(mem_ctx, &cd, opcode);
+ buflen = ctdb_req_control_data_len(&cd);
+ ctdb_req_control_data_push(&cd, BUFFER);
+ ret = ctdb_req_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
+ assert(ret == 0);
+ verify_ctdb_req_control_data(&cd, &cd2);
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_reply_control_data(void)
+{
+ TALLOC_CTX *mem_ctx;
+ size_t buflen;
+ int ret;
+ struct ctdb_reply_control_data cd, cd2;
+ uint32_t opcode;
+
+ printf("ctdb_reply_control_data\n");
+ fflush(stdout);
+
+ for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", opcode);
+ fflush(stdout);
+ fill_ctdb_reply_control_data(mem_ctx, &cd, opcode);
+ buflen = ctdb_reply_control_data_len(&cd);
+ ctdb_reply_control_data_push(&cd, BUFFER);
+ ret = ctdb_reply_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
+ assert(ret == 0);
+ verify_ctdb_reply_control_data(&cd, &cd2);
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_req_control(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_req_control c, c2;
+ uint32_t opcode;
+
+ printf("ctdb_req_control\n");
+ fflush(stdout);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CONTROL,
+ DESTNODE, SRCNODE, REQID);
+
+ for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", opcode);
+ fflush(stdout);
+ fill_ctdb_req_control(mem_ctx, &c, opcode);
+ datalen = ctdb_req_control_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_req_control_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_req_control_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_req_control_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_req_control(&c, &c2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_reply_control(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_reply_control c, c2;
+ uint32_t opcode;
+
+ printf("ctdb_reply_control\n");
+ fflush(stdout);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CONTROL,
+ DESTNODE, SRCNODE, REQID);
+
+ for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", opcode);
+ fflush(stdout);
+ fill_ctdb_reply_control(mem_ctx, &c, opcode);
+ datalen = ctdb_reply_control_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_reply_control_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_reply_control_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_reply_control_pull(pkt, pkt_len, opcode, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_reply_control(&c, &c2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_req_message_data(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *pkt;
+ size_t datalen, pkt_len, len;
+ int ret;
+ struct ctdb_req_header h, h2;
+ struct ctdb_req_message_data c, c2;
+
+ printf("ctdb_req_message\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_MESSAGE,
+ DESTNODE, SRCNODE, REQID);
+
+ fill_ctdb_req_message_data(mem_ctx, &c);
+ datalen = ctdb_req_message_data_len(&h, &c);
+ ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
+ assert(ret == 0);
+ assert(pkt != NULL);
+ assert(pkt_len >= datalen);
+ len = 0;
+ ret = ctdb_req_message_data_push(&h, &c, pkt, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == datalen);
+ ret = ctdb_req_message_data_push(&h, &c, pkt, &pkt_len);
+ assert(ret == 0);
+ ret = ctdb_req_message_data_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
+ assert(ret == 0);
+ verify_ctdb_req_header(&h, &h2);
+ assert(h2.length == pkt_len);
+ verify_ctdb_req_message_data(&c, &c2);
+
+ talloc_free(mem_ctx);
+}
+
+int main(int argc, char *argv[])
+{
+ if (argc == 2) {
+ int seed = atoi(argv[1]);
+ srandom(seed);
+ }
+
+ test_ctdb_req_header();
+
+ test_ctdb_req_call();
+ test_ctdb_reply_call();
+ test_ctdb_reply_error();
+ test_ctdb_req_dmaster();
+ test_ctdb_reply_dmaster();
+
+ test_ctdb_req_control_data();
+ test_ctdb_reply_control_data();
+
+ test_ctdb_req_control();
+ test_ctdb_reply_control();
+
+ test_ctdb_req_message_data();
+
+ return 0;
+}
--- /dev/null
+/*
+ protocol types tests
+
+ Copyright (C) Amitay Isaacs 2015
+
+ 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <assert.h>
+
+#include "protocol/protocol_basic.c"
+#include "protocol/protocol_types.c"
+#include "protocol/protocol_event.c"
+
+#include "tests/src/protocol_common.h"
+#include "tests/src/protocol_common_event.h"
+
+#define REQID 0x34567890
+
+
+/*
+ * Functions to test eventd protocol marshalling
+ */
+
+static void test_ctdb_event_header(void)
+{
+ TALLOC_CTX *mem_ctx;
+ size_t buflen;
+ struct ctdb_event_header h, h2;
+ int ret;
+
+ printf("ctdb_event_header\n");
+ fflush(stdout);
+
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ ctdb_event_header_fill(&h, REQID);
+
+ buflen = ctdb_event_header_len(&h);
+ ctdb_event_header_push(&h, BUFFER);
+ ret = ctdb_event_header_pull(BUFFER, buflen, mem_ctx, &h2);
+ assert(ret == 0);
+
+ verify_ctdb_event_header(&h, &h2);
+
+ talloc_free(mem_ctx);
+}
+
+#define NUM_COMMANDS 5
+
+static void test_ctdb_event_request_data(void)
+{
+ TALLOC_CTX *mem_ctx;
+ size_t buflen;
+ struct ctdb_event_request_data rd, rd2;
+ uint32_t command;
+ int ret;
+
+ printf("ctdb_event_request_data\n");
+ fflush(stdout);
+
+ for (command=1; command<=NUM_COMMANDS; command++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", command);
+ fflush(stdout);
+ fill_ctdb_event_request_data(mem_ctx, &rd, command);
+ buflen = ctdb_event_request_data_len(&rd);
+ ctdb_event_request_data_push(&rd, BUFFER);
+ ret = ctdb_event_request_data_pull(BUFFER, buflen, mem_ctx, &rd2);
+ assert(ret == 0);
+ verify_ctdb_event_request_data(&rd, &rd2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_event_reply_data(void)
+{
+ TALLOC_CTX *mem_ctx;
+ size_t buflen;
+ struct ctdb_event_reply_data rd, rd2;
+ uint32_t command;
+ int ret;
+
+ printf("ctdb_event_reply_data\n");
+ fflush(stdout);
+
+ for (command=1; command<=NUM_COMMANDS; command++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", command);
+ fflush(stdout);
+ fill_ctdb_event_reply_data(mem_ctx, &rd, command);
+ buflen = ctdb_event_reply_data_len(&rd);
+ ctdb_event_reply_data_push(&rd, BUFFER);
+ ret = ctdb_event_reply_data_pull(BUFFER, buflen, mem_ctx, &rd2);
+ assert(ret == 0);
+ verify_ctdb_event_reply_data(&rd, &rd2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_event_request(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *buf;
+ size_t len, buflen;
+ int ret;
+ struct ctdb_event_request r, r2;
+ uint32_t command;
+
+ printf("ctdb_event_request\n");
+ fflush(stdout);
+
+ for (command=1; command<=NUM_COMMANDS; command++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", command);
+ fflush(stdout);
+ fill_ctdb_event_request(mem_ctx, &r, command);
+ buflen = ctdb_event_request_len(&r);
+ buf = talloc_size(mem_ctx, buflen);
+ assert(buf != NULL);
+ len = 0;
+ ret = ctdb_event_request_push(&r, buf, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == buflen);
+ ret = ctdb_event_request_push(&r, buf, &buflen);
+ assert(ret == 0);
+ ret = ctdb_event_request_pull(buf, buflen, mem_ctx, &r2);
+ assert(ret == 0);
+ assert(r2.header.length == buflen);
+ verify_ctdb_event_request(&r, &r2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+static void test_ctdb_event_reply(void)
+{
+ TALLOC_CTX *mem_ctx;
+ uint8_t *buf;
+ size_t len, buflen;
+ int ret;
+ struct ctdb_event_reply r, r2;
+ uint32_t command;
+
+ printf("ctdb_event_reply\n");
+ fflush(stdout);
+
+ for (command=1; command<=NUM_COMMANDS; command++) {
+ mem_ctx = talloc_new(NULL);
+ assert(mem_ctx != NULL);
+
+ printf("%u.. ", command);
+ fflush(stdout);
+ fill_ctdb_event_reply(mem_ctx, &r, command);
+ buflen = ctdb_event_reply_len(&r);
+ buf = talloc_size(mem_ctx, buflen);
+ assert(buf != NULL);
+ len = 0;
+ ret = ctdb_event_reply_push(&r, buf, &len);
+ assert(ret == EMSGSIZE);
+ assert(len == buflen);
+ ret = ctdb_event_reply_push(&r, buf, &buflen);
+ assert(ret == 0);
+ ret = ctdb_event_reply_pull(buf, buflen, mem_ctx, &r2);
+ assert(ret == 0);
+ assert(r2.header.length == buflen);
+ verify_ctdb_event_reply(&r, &r2);
+
+ talloc_free(mem_ctx);
+ }
+
+ printf("\n");
+ fflush(stdout);
+}
+
+DEFINE_TEST(struct ctdb_event_request_run, ctdb_event_request_run);
+DEFINE_TEST(struct ctdb_event_request_status, ctdb_event_request_status);
+DEFINE_TEST(struct ctdb_event_request_script_enable,
+ ctdb_event_request_script_enable);
+DEFINE_TEST(struct ctdb_event_request_script_disable,
+ ctdb_event_request_script_disable);
+DEFINE_TEST(struct ctdb_event_reply_status, ctdb_event_reply_status);
+DEFINE_TEST(struct ctdb_event_reply_script_list, ctdb_event_reply_script_list);
+
+int main(int argc, char *argv[])
+{
+ if (argc == 2) {
+ int seed = atoi(argv[1]);
+ srandom(seed);
+ }
+
+ TEST_FUNC(ctdb_event_request_run)();
+ TEST_FUNC(ctdb_event_request_status)();
+ TEST_FUNC(ctdb_event_request_script_enable)();
+ TEST_FUNC(ctdb_event_request_script_disable)();
+ TEST_FUNC(ctdb_event_reply_status)();
+ TEST_FUNC(ctdb_event_reply_script_list)();
+
+ test_ctdb_event_header();
+
+ test_ctdb_event_request_data();
+ test_ctdb_event_reply_data();
+ test_ctdb_event_request();
+ test_ctdb_event_reply();
+
+ return 0;
+}
*/
#include "replace.h"
-#include "system/network.h"
#include "system/filesys.h"
#include <assert.h>
#include "protocol/protocol_basic.c"
#include "protocol/protocol_types.c"
-#include "protocol/protocol_header.c"
-#include "protocol/protocol_call.c"
-#include "protocol/protocol_control.c"
-#include "protocol/protocol_event.c"
-#include "protocol/protocol_message.c"
-#include "protocol/protocol_packet.c"
-uint8_t BUFFER[1024*1024];
-
-/*
- * Functions to generation random data
- */
-
-static int rand_int(int max)
-{
- return random() % max;
-}
-
-static uint8_t rand8(void)
-{
- uint8_t val = rand_int(256) & 0xff;
- return val;
-}
-
-static int32_t rand32i(void)
-{
- return INT_MIN + random();
-}
-
-static uint32_t rand32(void)
-{
- return random();
-}
-
-static uint64_t rand64(void)
-{
- uint64_t t = random();
- t = (t << 32) | random();
- return t;
-}
-
-static double rand_double(void)
-{
- return 1.0 / rand64();
-}
-
-static void fill_buffer(void *p, size_t len)
-{
- int i;
- uint8_t *ptr = p;
-
- for (i=0; i<len; i++) {
- ptr[i] = rand8();
- }
-}
-
-static void verify_buffer(void *p1, void *p2, size_t len)
-{
- if (len > 0) {
- assert(memcmp(p1, p2, len) == 0);
- }
-}
-
-/*
- * Functions to fill and verify data types
- */
-
-static void fill_tdb_data_nonnull(TALLOC_CTX *mem_ctx, TDB_DATA *p)
-{
- p->dsize = rand_int(1024) + 1;
- p->dptr = talloc_array(mem_ctx, uint8_t, p->dsize);
- assert(p->dptr != NULL);
- fill_buffer(p->dptr, p->dsize);
-}
-
-static void fill_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p)
-{
- if (rand_int(5) == 0) {
- p->dsize = 0;
- p->dptr = NULL;
- } else {
- fill_tdb_data_nonnull(mem_ctx, p);
- }
-}
-
-static void verify_tdb_data(TDB_DATA *p1, TDB_DATA *p2)
-{
- assert(p1->dsize == p2->dsize);
- verify_buffer(p1->dptr, p2->dptr, p1->dsize);
-}
-
-static void fill_ctdb_statistics(TALLOC_CTX *mem_ctx, struct ctdb_statistics *p)
-{
- fill_buffer((uint8_t *)p, sizeof(struct ctdb_statistics));
-}
-
-static void verify_ctdb_statistics(struct ctdb_statistics *p1,
- struct ctdb_statistics *p2)
-{
- verify_buffer(p1, p2, sizeof(struct ctdb_statistics));
-}
-
-static void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p)
-{
- int i;
-
- p->generation = rand32();
- p->size = rand_int(20);
- if (p->size > 0) {
- p->map = talloc_array(mem_ctx, uint32_t, p->size);
- assert(p->map != NULL);
-
- for (i=0; i<p->size; i++) {
- p->map[i] = rand32();
- }
- } else {
- p->map = NULL;
- }
-}
-
-static void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1,
- struct ctdb_vnn_map *p2)
-{
- int i;
-
- assert(p1->generation == p2->generation);
- assert(p1->size == p2->size);
- for (i=0; i<p1->size; i++) {
- assert(p1->map[i] == p2->map[i]);
- }
-}
-
-static void fill_ctdb_dbid(TALLOC_CTX *mem_ctx, struct ctdb_dbid *p)
-{
- p->db_id = rand32();
- p->flags = rand8();
-}
-
-static void verify_ctdb_dbid(struct ctdb_dbid *p1, struct ctdb_dbid *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->flags == p2->flags);
-}
-
-static void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p)
-{
- int i;
-
- p->num = rand_int(40);
- if (p->num > 0) {
- p->dbs = talloc_array(mem_ctx, struct ctdb_dbid, p->num);
- assert(p->dbs != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_dbid(mem_ctx, &p->dbs[i]);
- }
- } else {
- p->dbs = NULL;
- }
-}
-
-static void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1,
- struct ctdb_dbid_map *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_dbid(&p1->dbs[i], &p2->dbs[i]);
- }
-}
-
-static void fill_ctdb_pulldb(TALLOC_CTX *mem_ctx, struct ctdb_pulldb *p)
-{
- p->db_id = rand32();
- p->lmaster = rand32();
-}
-
-static void verify_ctdb_pulldb(struct ctdb_pulldb *p1, struct ctdb_pulldb *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->lmaster == p2->lmaster);
-}
-
-static void fill_ctdb_pulldb_ext(TALLOC_CTX *mem_ctx,
- struct ctdb_pulldb_ext *p)
-{
- p->db_id = rand32();
- p->lmaster = rand32();
- p->srvid = rand64();
-}
-
-static void verify_ctdb_pulldb_ext(struct ctdb_pulldb_ext *p1,
- struct ctdb_pulldb_ext *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->lmaster == p2->lmaster);
- assert(p1->srvid == p2->srvid);
-}
-
-static void fill_ctdb_ltdb_header(TALLOC_CTX *mem_ctx,
- struct ctdb_ltdb_header *p)
-{
- p->rsn = rand64();
- p->dmaster = rand32();
- p->flags = rand32();
-}
-
-static void verify_ctdb_ltdb_header(struct ctdb_ltdb_header *p1,
- struct ctdb_ltdb_header *p2)
-{
- assert(p1->rsn == p2->rsn);
- assert(p1->dmaster == p2->dmaster);
- assert(p1->flags == p2->flags);
-}
-
-static void fill_ctdb_rec_data(TALLOC_CTX *mem_ctx, struct ctdb_rec_data *p)
-{
- p->reqid = rand32();
- if (p->reqid % 5 == 0) {
- p->header = talloc(mem_ctx, struct ctdb_ltdb_header);
- assert(p->header != NULL);
- fill_ctdb_ltdb_header(mem_ctx, p->header);
- } else {
- p->header = NULL;
- }
- fill_tdb_data_nonnull(mem_ctx, &p->key);
- fill_tdb_data(mem_ctx, &p->data);
-}
-
-static void verify_ctdb_rec_data(struct ctdb_rec_data *p1,
- struct ctdb_rec_data *p2)
-{
- struct ctdb_ltdb_header header;
-
- assert(p1->reqid == p2->reqid);
- if (p1->header != NULL) {
- assert(ctdb_ltdb_header_extract(&p2->data, &header) == 0);
- verify_ctdb_ltdb_header(p1->header, &header);
- }
- verify_tdb_data(&p1->key, &p2->key);
- verify_tdb_data(&p1->data, &p2->data);
-}
-
-static void fill_ctdb_rec_buffer(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *p)
-{
- struct ctdb_rec_data rec;
- int ret, i;
- int count;
-
- p->db_id = rand32();
- p->count = 0;
- p->buf = NULL;
- p->buflen = 0;
-
- count = rand_int(100);
- if (count > 0) {
- for (i=0; i<count; i++) {
- fill_ctdb_rec_data(mem_ctx, &rec);
- ret = ctdb_rec_buffer_add(mem_ctx, p, rec.reqid,
- rec.header,
- rec.key, rec.data);
- assert(ret == 0);
- }
- }
-}
-
-static void verify_ctdb_rec_buffer(struct ctdb_rec_buffer *p1,
- struct ctdb_rec_buffer *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->count == p2->count);
- assert(p1->buflen == p2->buflen);
- verify_buffer(p1->buf, p2->buf, p1->buflen);
-}
-
-static void fill_ctdb_traverse_start(TALLOC_CTX *mem_ctx,
- struct ctdb_traverse_start *p)
-{
- p->db_id = rand32();
- p->reqid = rand32();
- p->srvid = rand64();
-}
-
-static void verify_ctdb_traverse_start(struct ctdb_traverse_start *p1,
- struct ctdb_traverse_start *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->reqid == p2->reqid);
- assert(p1->srvid == p2->srvid);
-}
-
-static void fill_ctdb_traverse_all(TALLOC_CTX *mem_ctx,
- struct ctdb_traverse_all *p)
-{
- p->db_id = rand32();
- p->reqid = rand32();
- p->pnn = rand32();
- p->client_reqid = rand32();
- p->srvid = rand64();
-}
-
-static void verify_ctdb_traverse_all(struct ctdb_traverse_all *p1,
- struct ctdb_traverse_all *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->reqid == p2->reqid);
- assert(p1->pnn == p2->pnn);
- assert(p1->client_reqid == p2->client_reqid);
- assert(p1->srvid == p2->srvid);
-}
-
-static void fill_ctdb_traverse_start_ext(TALLOC_CTX *mem_ctx,
- struct ctdb_traverse_start_ext *p)
-{
- p->db_id = rand32();
- p->reqid = rand32();
- p->srvid = rand64();
- p->withemptyrecords = rand_int(2);
-}
-
-static void verify_ctdb_traverse_start_ext(struct ctdb_traverse_start_ext *p1,
- struct ctdb_traverse_start_ext *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->reqid == p2->reqid);
- assert(p1->srvid == p2->srvid);
- assert(p1->withemptyrecords == p2->withemptyrecords);
-}
-
-static void fill_ctdb_traverse_all_ext(TALLOC_CTX *mem_ctx,
- struct ctdb_traverse_all_ext *p)
-{
- p->db_id = rand32();
- p->reqid = rand32();
- p->pnn = rand32();
- p->client_reqid = rand32();
- p->srvid = rand64();
- p->withemptyrecords = rand_int(2);
-}
-
-static void verify_ctdb_traverse_all_ext(struct ctdb_traverse_all_ext *p1,
- struct ctdb_traverse_all_ext *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->reqid == p2->reqid);
- assert(p1->pnn == p2->pnn);
- assert(p1->client_reqid == p2->client_reqid);
- assert(p1->srvid == p2->srvid);
- assert(p1->withemptyrecords == p2->withemptyrecords);
-}
-
-static void fill_ctdb_sock_addr(TALLOC_CTX *mem_ctx, ctdb_sock_addr *p)
-{
- if (rand_int(2) == 0) {
- p->ip.sin_family = AF_INET;
- p->ip.sin_port = rand_int(65535);
- fill_buffer(&p->ip.sin_addr, sizeof(struct in_addr));
- } else {
- p->ip6.sin6_family = AF_INET6;
- p->ip6.sin6_port = rand_int(65535);
- fill_buffer(&p->ip6.sin6_addr, sizeof(struct in6_addr));
- }
-}
-
-static void verify_ctdb_sock_addr(ctdb_sock_addr *p1, ctdb_sock_addr *p2)
-{
- assert(p1->sa.sa_family == p2->sa.sa_family);
- if (p1->sa.sa_family == AF_INET) {
- assert(p1->ip.sin_port == p2->ip.sin_port);
- verify_buffer(&p1->ip.sin_addr, &p2->ip.sin_addr,
- sizeof(struct in_addr));
- } else {
- assert(p1->ip6.sin6_port == p2->ip6.sin6_port);
- verify_buffer(&p1->ip6.sin6_addr, &p2->ip6.sin6_addr,
- sizeof(struct in6_addr));
- }
-}
-
-static void fill_ctdb_connection(TALLOC_CTX *mem_ctx,
- struct ctdb_connection *p)
-{
- fill_ctdb_sock_addr(mem_ctx, &p->src);
- fill_ctdb_sock_addr(mem_ctx, &p->dst);
-}
-
-static void verify_ctdb_connection(struct ctdb_connection *p1,
- struct ctdb_connection *p2)
-{
- verify_ctdb_sock_addr(&p1->src, &p2->src);
- verify_ctdb_sock_addr(&p1->dst, &p2->dst);
-}
-
-static void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **out)
-{
- char *p;
- int len, i;
-
- len = rand_int(1024) + 1;
- p = talloc_size(mem_ctx, len+1);
- assert(p != NULL);
-
- for (i=0; i<len; i++) {
- p[i] = 'A' + rand_int(26);
- }
- p[len] = '\0';
- *out = p;
-}
-
-static void verify_ctdb_string(const char *p1, const char *p2)
-{
- if (p1 == NULL || p2 == NULL) {
- assert(p1 == p2);
- } else {
- assert(strlen(p1) == strlen(p2));
- assert(strcmp(p1, p2) == 0);
- }
-}
-
-static void fill_ctdb_tunable(TALLOC_CTX *mem_ctx, struct ctdb_tunable *p)
-{
- fill_ctdb_string(mem_ctx, discard_const(&p->name));
- p->value = rand32();
-}
-
-static void verify_ctdb_tunable(struct ctdb_tunable *p1,
- struct ctdb_tunable *p2)
-{
- verify_ctdb_string(discard_const(p1->name), discard_const(p2->name));
- assert(p1->value == p2->value);
-}
-
-static void fill_ctdb_node_flag_change(TALLOC_CTX *mem_ctx,
- struct ctdb_node_flag_change *p)
-{
- p->pnn = rand32();
- p->new_flags = rand32();
- p->old_flags = rand32();
-}
-
-static void verify_ctdb_node_flag_change(struct ctdb_node_flag_change *p1,
- struct ctdb_node_flag_change *p2)
-{
- assert(p1->pnn == p2->pnn);
- assert(p1->new_flags == p2->new_flags);
- assert(p1->old_flags == p2->old_flags);
-}
-
-static void fill_ctdb_var_list(TALLOC_CTX *mem_ctx,
- struct ctdb_var_list *p)
-{
- int i;
-
- p->count = rand_int(100) + 1;
- p->var = talloc_array(mem_ctx, const char *, p->count);
- for (i=0; i<p->count; i++) {
- fill_ctdb_string(p->var, discard_const(&p->var[i]));
- }
-}
-
-static void verify_ctdb_var_list(struct ctdb_var_list *p1,
- struct ctdb_var_list *p2)
-{
- int i;
-
- assert(p1->count == p2->count);
- for (i=0; i<p1->count; i++) {
- verify_ctdb_string(discard_const(p1->var[i]),
- discard_const(p2->var[i]));
- }
-}
-
-static void fill_ctdb_tunable_list(TALLOC_CTX *mem_ctx,
- struct ctdb_tunable_list *p)
-{
- fill_buffer(p, sizeof(struct ctdb_tunable_list));
-}
-
-static void verify_ctdb_tunable_list(struct ctdb_tunable_list *p1,
- struct ctdb_tunable_list *p2)
-{
- verify_buffer(p1, p2, sizeof(struct ctdb_tunable_list));
-}
-
-static void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx,
- struct ctdb_tickle_list *p)
-{
- int i;
-
- fill_ctdb_sock_addr(mem_ctx, &p->addr);
- p->num = rand_int(1000);
- if (p->num > 0) {
- p->conn = talloc_array(mem_ctx, struct ctdb_connection, p->num);
- assert(p->conn != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_connection(mem_ctx, &p->conn[i]);
- }
- } else {
- p->conn = NULL;
- }
-}
-
-static void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
- struct ctdb_tickle_list *p2)
-{
- int i;
-
- verify_ctdb_sock_addr(&p1->addr, &p2->addr);
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_connection(&p1->conn[i], &p2->conn[i]);
- }
-}
-
-static void fill_ctdb_addr_info(TALLOC_CTX *mem_ctx, struct ctdb_addr_info *p)
-{
- fill_ctdb_sock_addr(mem_ctx, &p->addr);
- p->mask = rand_int(33);
- if (rand_int(2) == 0) {
- p->iface = NULL;
- } else {
- fill_ctdb_string(mem_ctx, &p->iface);
- }
-}
-
-static void verify_ctdb_addr_info(struct ctdb_addr_info *p1,
- struct ctdb_addr_info *p2)
-{
- verify_ctdb_sock_addr(&p1->addr, &p2->addr);
- assert(p1->mask == p2->mask);
- verify_ctdb_string(p1->iface, p2->iface);
-}
-
-static void fill_ctdb_transdb(TALLOC_CTX *mem_ctx, struct ctdb_transdb *p)
-{
- p->db_id = rand32();
- p->tid = rand32();
-}
-
-static void verify_ctdb_transdb(struct ctdb_transdb *p1, struct ctdb_transdb *p2)
-{
- assert(p1->db_id == p2->db_id);
- assert(p1->tid == p2->tid);
-}
-
-static void fill_ctdb_uptime(TALLOC_CTX *mem_ctx, struct ctdb_uptime *p)
-{
- fill_buffer(p, sizeof(struct ctdb_uptime));
-}
-
-static void verify_ctdb_uptime(struct ctdb_uptime *p1, struct ctdb_uptime *p2)
-{
- verify_buffer(p1, p2, sizeof(struct ctdb_uptime));
-}
-
-static void fill_ctdb_public_ip(TALLOC_CTX *mem_ctx, struct ctdb_public_ip *p)
-{
- p->pnn = rand32();
- fill_ctdb_sock_addr(mem_ctx, &p->addr);
-}
-
-static void verify_ctdb_public_ip(struct ctdb_public_ip *p1,
- struct ctdb_public_ip *p2)
-{
- assert(p1->pnn == p2->pnn);
- verify_ctdb_sock_addr(&p1->addr, &p2->addr);
-}
-
-static void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
- struct ctdb_public_ip_list *p)
-{
- int i;
-
- p->num = rand_int(32);
- if (p->num > 0) {
- p->ip = talloc_array(mem_ctx, struct ctdb_public_ip, p->num);
- assert(p->ip != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_public_ip(mem_ctx, &p->ip[i]);
- }
- } else {
- p->ip = NULL;
- }
-}
-
-static void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
- struct ctdb_public_ip_list *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_public_ip(&p1->ip[i], &p2->ip[i]);
- }
-}
-
-static void fill_ctdb_node_and_flags(TALLOC_CTX *mem_ctx,
- struct ctdb_node_and_flags *p)
-{
- p->pnn = rand32();
- p->flags = rand32();
- fill_ctdb_sock_addr(mem_ctx, &p->addr);
-}
-
-static void verify_ctdb_node_and_flags(struct ctdb_node_and_flags *p1,
- struct ctdb_node_and_flags *p2)
-{
- assert(p1->pnn == p2->pnn);
- assert(p1->flags == p2->flags);
- verify_ctdb_sock_addr(&p1->addr, &p2->addr);
-}
-
-static void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p)
-{
- int i;
-
- p->num = rand_int(32);
- if (p->num > 0) {
- p->node = talloc_array(mem_ctx, struct ctdb_node_and_flags,
- p->num);
- assert(p->node != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_node_and_flags(mem_ctx, &p->node[i]);
- }
- } else {
- p->node = NULL;
- }
-}
-
-static void verify_ctdb_node_map(struct ctdb_node_map *p1,
- struct ctdb_node_map *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_node_and_flags(&p1->node[i], &p2->node[i]);
- }
-}
-
-static void fill_ctdb_script(TALLOC_CTX *mem_ctx, struct ctdb_script *p)
-{
- fill_buffer(p, sizeof(struct ctdb_script));
-}
-
-static void verify_ctdb_script(struct ctdb_script *p1, struct ctdb_script *p2)
-{
- verify_buffer(p1, p2, sizeof(struct ctdb_script));
-}
-
-static void fill_ctdb_script_list(TALLOC_CTX *mem_ctx,
- struct ctdb_script_list *p)
-{
- int i;
-
- p->num_scripts = rand_int(32);
- if (p->num_scripts > 0) {
- p->script = talloc_array(mem_ctx, struct ctdb_script,
- p->num_scripts);
- assert(p->script != NULL);
- for (i=0; i<p->num_scripts; i++) {
- fill_ctdb_script(mem_ctx, &p->script[i]);
- }
- } else {
- p->script = NULL;
- }
-}
-
-static void verify_ctdb_script_list(struct ctdb_script_list *p1,
- struct ctdb_script_list *p2)
-{
- int i;
-
- assert(p1->num_scripts == p2->num_scripts);
- for (i=0; i<p1->num_scripts; i++) {
- verify_ctdb_script(&p1->script[i], &p2->script[i]);
- }
-}
-
-static void fill_ctdb_ban_state(TALLOC_CTX *mem_ctx, struct ctdb_ban_state *p)
-{
- p->pnn = rand32();
- p->time = rand32();
-}
-
-static void verify_ctdb_ban_state(struct ctdb_ban_state *p1,
- struct ctdb_ban_state *p2)
-{
- assert(p1->pnn == p2->pnn);
- assert(p1->time == p2->time);
-}
-
-static void fill_ctdb_notify_data(TALLOC_CTX *mem_ctx,
- struct ctdb_notify_data *p)
-{
- p->srvid = rand64();
- fill_tdb_data(mem_ctx, &p->data);
-}
-
-static void verify_ctdb_notify_data(struct ctdb_notify_data *p1,
- struct ctdb_notify_data *p2)
-{
- assert(p1->srvid == p2->srvid);
- verify_tdb_data(&p1->data, &p2->data);
-}
-
-static void fill_ctdb_iface(TALLOC_CTX *mem_ctx, struct ctdb_iface *p)
-{
- fill_buffer(p, sizeof(struct ctdb_iface));
-}
-
-static void verify_ctdb_iface(struct ctdb_iface *p1, struct ctdb_iface *p2)
-{
- verify_buffer(p1, p2, sizeof(struct ctdb_iface));
-}
-
-static void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx,
- struct ctdb_iface_list *p)
-{
- int i;
-
- p->num = rand_int(32);
- if (p->num > 0) {
- p->iface = talloc_array(mem_ctx, struct ctdb_iface, p->num);
- assert(p->iface != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_iface(mem_ctx, &p->iface[i]);
- }
- } else {
- p->iface = NULL;
- }
-}
-
-static void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
- struct ctdb_iface_list *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_iface(&p1->iface[i], &p2->iface[i]);
- }
-}
-
-static void fill_ctdb_public_ip_info(TALLOC_CTX *mem_ctx,
- struct ctdb_public_ip_info *p)
-{
- fill_ctdb_public_ip(mem_ctx, &p->ip);
- p->active_idx = rand_int(32) + 1;
- p->ifaces = talloc(mem_ctx, struct ctdb_iface_list);
- assert(p->ifaces != NULL);
- fill_ctdb_iface_list(mem_ctx, p->ifaces);
-}
-
-static void verify_ctdb_public_ip_info(struct ctdb_public_ip_info *p1,
- struct ctdb_public_ip_info *p2)
-{
- verify_ctdb_public_ip(&p1->ip, &p2->ip);
- assert(p1->active_idx == p2->active_idx);
- verify_ctdb_iface_list(p1->ifaces, p2->ifaces);
-}
-
-static void fill_ctdb_statistics_list(TALLOC_CTX *mem_ctx,
- struct ctdb_statistics_list *p)
-{
- int i;
-
- p->num = rand_int(10);
- if (p->num > 0) {
- p->stats = talloc_array(mem_ctx, struct ctdb_statistics,
- p->num);
- assert(p->stats != NULL);
-
- for (i=0; i<p->num; i++) {
- fill_ctdb_statistics(mem_ctx, &p->stats[i]);
- }
- } else {
- p->stats = NULL;
- }
-}
-
-static void verify_ctdb_statistics_list(struct ctdb_statistics_list *p1,
- struct ctdb_statistics_list *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_statistics(&p1->stats[i], &p2->stats[i]);
- }
-}
-
-static void fill_ctdb_key_data(TALLOC_CTX *mem_ctx, struct ctdb_key_data *p)
-{
- p->db_id = rand32();
- fill_ctdb_ltdb_header(mem_ctx, &p->header);
- fill_tdb_data_nonnull(mem_ctx, &p->key);
-}
-
-static void verify_ctdb_key_data(struct ctdb_key_data *p1,
- struct ctdb_key_data *p2)
-{
- assert(p1->db_id == p2->db_id);
- verify_ctdb_ltdb_header(&p1->header, &p2->header);
- verify_tdb_data(&p1->key, &p2->key);
-}
-
-static void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
- struct ctdb_db_statistics *p)
-{
- int i;
-
- fill_buffer(p, offsetof(struct ctdb_db_statistics, num_hot_keys));
- p->num_hot_keys = 10;
- for (i=0; i<p->num_hot_keys; i++) {
- p->hot_keys[i].count = rand32();
- fill_tdb_data(mem_ctx, &p->hot_keys[i].key);
- }
-}
-
-static void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
- struct ctdb_db_statistics *p2)
-{
- int i;
-
- verify_buffer(p1, p2, offsetof(struct ctdb_db_statistics,
- num_hot_keys));
- assert(p1->num_hot_keys == p2->num_hot_keys);
- for (i=0; i<p1->num_hot_keys; i++) {
- assert(p1->hot_keys[i].count == p2->hot_keys[i].count);
- verify_tdb_data(&p1->hot_keys[i].key, &p2->hot_keys[i].key);
- }
-}
-
-static void fill_ctdb_event_request_run(TALLOC_CTX *mem_ctx,
- struct ctdb_event_request_run *p)
-{
- p->event = rand_int(CTDB_EVENT_MAX);
- p->timeout = rand();
- fill_ctdb_string(mem_ctx, &p->arg_str);
-}
-
-static void verify_ctdb_event_request_run(struct ctdb_event_request_run *p1,
- struct ctdb_event_request_run *p2)
-{
- assert(p1->event == p2->event);
- assert(p1->timeout == p2->timeout);
- verify_ctdb_string(p1->arg_str, p2->arg_str);
-}
-
-static void fill_ctdb_event_request_status(TALLOC_CTX *mem_ctx,
- struct ctdb_event_request_status *p)
-{
- p->event = rand_int(CTDB_EVENT_MAX);
- p->state = rand_int(3) + 1;
-}
-
-static void verify_ctdb_event_request_status(
- struct ctdb_event_request_status *p1,
- struct ctdb_event_request_status *p2)
-{
- assert(p1->event == p2->event);
- assert(p1->state == p2->state);
-}
-
-static void fill_ctdb_event_request_script_enable(
- TALLOC_CTX *mem_ctx,
- struct ctdb_event_request_script_enable *p)
-{
- fill_ctdb_string(mem_ctx, &p->script_name);
-}
-
-static void verify_ctdb_event_request_script_enable(
- struct ctdb_event_request_script_enable *p1,
- struct ctdb_event_request_script_enable *p2)
-{
- verify_ctdb_string(p1->script_name, p2->script_name);
-}
-
-static void fill_ctdb_event_request_script_disable(
- TALLOC_CTX *mem_ctx,
- struct ctdb_event_request_script_disable *p)
-{
- fill_ctdb_string(mem_ctx, &p->script_name);
-}
-
-static void verify_ctdb_event_request_script_disable(
- struct ctdb_event_request_script_disable *p1,
- struct ctdb_event_request_script_disable *p2)
-{
- verify_ctdb_string(p1->script_name, p2->script_name);
-}
-
-static void fill_ctdb_event_reply_status(TALLOC_CTX *mem_ctx,
- struct ctdb_event_reply_status *p)
-{
- if (rand_int(2) == 0) {
- p->status = 0;
- p->script_list = talloc(mem_ctx, struct ctdb_script_list);
- assert(p->script_list != NULL);
- fill_ctdb_script_list(mem_ctx, p->script_list);
- } else {
- p->status = rand32i();
- p->script_list = NULL;
- }
-}
-
-static void verify_ctdb_event_reply_status(struct ctdb_event_reply_status *p1,
- struct ctdb_event_reply_status *p2)
-{
- assert(p1->status == p2->status);
- if (p1->script_list == NULL) {
- assert(p1->script_list == p2->script_list);
- } else {
- verify_ctdb_script_list(p1->script_list, p2->script_list);
- }
-}
-
-static void fill_ctdb_event_reply_script_list(
- TALLOC_CTX *mem_ctx,
- struct ctdb_event_reply_script_list *p)
-{
- p->script_list = talloc(mem_ctx, struct ctdb_script_list);
- assert(p->script_list != NULL);
-
- fill_ctdb_script_list(mem_ctx, p->script_list);
-}
-
-static void verify_ctdb_event_reply_script_list(
- struct ctdb_event_reply_script_list *p1,
- struct ctdb_event_reply_script_list *p2)
-{
- verify_ctdb_script_list(p1->script_list, p2->script_list);
-}
-
-#ifndef PROTOCOL_TEST
-
-static void fill_ctdb_election_message(TALLOC_CTX *mem_ctx,
- struct ctdb_election_message *p)
-{
- p->num_connected = rand_int(32);
- fill_buffer(&p->priority_time, sizeof(struct timeval));
- p->pnn = rand_int(32);
- p->node_flags = rand32();
-}
-
-static void verify_ctdb_election_message(struct ctdb_election_message *p1,
- struct ctdb_election_message *p2)
-{
- assert(p1->num_connected == p2->num_connected);
- verify_buffer(p1, p2, sizeof(struct timeval));
- assert(p1->pnn == p2->pnn);
- assert(p1->node_flags == p2->node_flags);
-}
-
-static void fill_ctdb_srvid_message(TALLOC_CTX *mem_ctx,
- struct ctdb_srvid_message *p)
-{
- p->pnn = rand_int(32);
- p->srvid = rand64();
-}
-
-static void verify_ctdb_srvid_message(struct ctdb_srvid_message *p1,
- struct ctdb_srvid_message *p2)
-{
- assert(p1->pnn == p2->pnn);
- assert(p1->srvid == p2->srvid);
-}
-
-static void fill_ctdb_disable_message(TALLOC_CTX *mem_ctx,
- struct ctdb_disable_message *p)
-{
- p->pnn = rand_int(32);
- p->srvid = rand64();
- p->timeout = rand32();
-}
-
-static void verify_ctdb_disable_message(struct ctdb_disable_message *p1,
- struct ctdb_disable_message *p2)
-{
- assert(p1->pnn == p2->pnn);
- assert(p1->srvid == p2->srvid);
- assert(p1->timeout == p2->timeout);
-}
-
-static void fill_ctdb_server_id(TALLOC_CTX *mem_ctx,
- struct ctdb_server_id *p)
-{
- p->pid = rand64();
- p->task_id = rand32();
- p->vnn = rand_int(32);
- p->unique_id = rand64();
-}
-
-static void verify_ctdb_server_id(struct ctdb_server_id *p1,
- struct ctdb_server_id *p2)
-{
- assert(p1->pid == p2->pid);
- assert(p1->task_id == p2->task_id);
- assert(p1->vnn == p2->vnn);
- assert(p1->unique_id == p2->unique_id);
-}
-
-static void fill_ctdb_g_lock(TALLOC_CTX *mem_ctx, struct ctdb_g_lock *p)
-{
- p->type = rand_int(2);
- fill_ctdb_server_id(mem_ctx, &p->sid);
-}
-
-static void verify_ctdb_g_lock(struct ctdb_g_lock *p1, struct ctdb_g_lock *p2)
-{
- assert(p1->type == p2->type);
- verify_ctdb_server_id(&p1->sid, &p2->sid);
-}
-
-static void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx,
- struct ctdb_g_lock_list *p)
-{
- int i;
-
- p->num = rand_int(20) + 1;
- p->lock = talloc_array(mem_ctx, struct ctdb_g_lock, p->num);
- assert(p->lock != NULL);
- for (i=0; i<p->num; i++) {
- fill_ctdb_g_lock(mem_ctx, &p->lock[i]);
- }
-}
-
-static void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
- struct ctdb_g_lock_list *p2)
-{
- int i;
-
- assert(p1->num == p2->num);
- for (i=0; i<p1->num; i++) {
- verify_ctdb_g_lock(&p1->lock[i], &p2->lock[i]);
- }
-}
-
-/*
- * Functions to test marshalling routines
- */
-
-static void test_ctdb_int32(void)
-{
- int32_t p1, p2;
- size_t buflen;
- int ret;
-
- p1 = rand32i();
- buflen = ctdb_int32_len(p1);
- ctdb_int32_push(p1, BUFFER);
- ret = ctdb_int32_pull(BUFFER, buflen, NULL, &p2);
- assert(ret == 0);
- assert(p1 == p2);
-}
-
-static void test_ctdb_uint32(void)
-{
- uint32_t p1, p2;
- size_t buflen;
- int ret;
-
- p1 = rand32();
- buflen = ctdb_uint32_len(p1);
- ctdb_uint32_push(p1, BUFFER);
- ret = ctdb_uint32_pull(BUFFER, buflen, NULL, &p2);
- assert(ret == 0);
- assert(p1 == p2);
-}
-
-static void test_ctdb_uint64(void)
-{
- uint64_t p1, p2;
- size_t buflen;
- int ret;
-
- p1 = rand64();
- buflen = ctdb_uint64_len(p1);
- ctdb_uint64_push(p1, BUFFER);
- ret = ctdb_uint64_pull(BUFFER, buflen, NULL, &p2);
- assert(ret == 0);
- assert(p1 == p2);
-}
-
-static void test_ctdb_double(void)
-{
- double p1, p2;
- size_t buflen;
- int ret;
-
- p1 = rand_double();
- buflen = ctdb_double_len(p1);
- ctdb_double_push(p1, BUFFER);
- ret = ctdb_double_pull(BUFFER, buflen, NULL, &p2);
- assert(ret == 0);
- assert(p1 == p2);
-}
-
-static void test_ctdb_pid(void)
-{
- pid_t p1, p2;
- size_t buflen;
- int ret;
-
- p1 = rand32();
- buflen = ctdb_pid_len(p1);
- ctdb_pid_push(p1, BUFFER);
- ret = ctdb_pid_pull(BUFFER, buflen, NULL, &p2);
- assert(ret == 0);
- assert(p1 == p2);
-}
-
-#define TEST_FUNC(NAME) test_ ##NAME
-#define FILL_FUNC(NAME) fill_ ##NAME
-#define VERIFY_FUNC(NAME) verify_ ##NAME
-#define LEN_FUNC(NAME) NAME## _len
-#define PUSH_FUNC(NAME) NAME## _push
-#define PULL_FUNC(NAME) NAME## _pull
-
-#define DEFINE_TEST(TYPE, NAME) \
-static void TEST_FUNC(NAME)(void) \
-{ \
- TALLOC_CTX *mem_ctx = talloc_new(NULL); \
- TYPE *p1, *p2; \
- size_t buflen; \
- int ret; \
-\
- p1 = talloc_zero(mem_ctx, TYPE); \
- assert(p1 != NULL); \
- FILL_FUNC(NAME)(p1, p1); \
- buflen = LEN_FUNC(NAME)(p1); \
- PUSH_FUNC(NAME)(p1, BUFFER); \
- ret = PULL_FUNC(NAME)(BUFFER, buflen, mem_ctx, &p2); \
- assert(ret == 0); \
- VERIFY_FUNC(NAME)(p1, p2); \
- talloc_free(mem_ctx); \
-}
-
-
-static void test_ctdb_string(void)
-{
- TALLOC_CTX *mem_ctx = talloc_new(NULL);
- const char *p1, *p2;
- size_t buflen;
- int ret;
-
- fill_ctdb_string(mem_ctx, &p1);
- buflen = ctdb_string_len(p1);
- ctdb_string_push(p1, BUFFER);
- ret = ctdb_string_pull(BUFFER, buflen, mem_ctx, &p2);
- assert(ret == 0);
- verify_ctdb_string(p1, p2);
- talloc_free(mem_ctx);
-}
-
-static void test_ctdb_stringn(void)
-{
- TALLOC_CTX *mem_ctx = talloc_new(NULL);
- const char *p1, *p2;
- size_t buflen;
- int ret;
-
- fill_ctdb_string(mem_ctx, &p1);
- buflen = ctdb_stringn_len(p1);
- ctdb_stringn_push(p1, BUFFER);
- ret = ctdb_stringn_pull(BUFFER, buflen, mem_ctx, &p2);
- assert(ret == 0);
- verify_ctdb_string(p1, p2);
- talloc_free(mem_ctx);
-}
+#include "tests/src/protocol_common.h"
static void test_ctdb_ltdb_header(void)
{
DEFINE_TEST(struct ctdb_disable_message, ctdb_disable_message);
DEFINE_TEST(struct ctdb_g_lock_list, ctdb_g_lock_list);
-DEFINE_TEST(struct ctdb_event_request_run, ctdb_event_request_run);
-DEFINE_TEST(struct ctdb_event_request_status, ctdb_event_request_status);
-DEFINE_TEST(struct ctdb_event_request_script_enable,
- ctdb_event_request_script_enable);
-DEFINE_TEST(struct ctdb_event_request_script_disable,
- ctdb_event_request_script_disable);
-DEFINE_TEST(struct ctdb_event_reply_status, ctdb_event_reply_status);
-DEFINE_TEST(struct ctdb_event_reply_script_list, ctdb_event_reply_script_list);
-
static void test_ctdb_rec_buffer_read_write(void)
{
TALLOC_CTX *mem_ctx = talloc_new(NULL);
srandom(seed);
}
- test_ctdb_int32();
- test_ctdb_uint32();
- test_ctdb_uint64();
- test_ctdb_double();
- test_ctdb_pid();
-
- test_ctdb_string();
- test_ctdb_stringn();
-
test_ctdb_ltdb_header();
test_ctdb_g_lock();
TEST_FUNC(ctdb_disable_message)();
TEST_FUNC(ctdb_g_lock_list)();
- TEST_FUNC(ctdb_event_request_run)();
- TEST_FUNC(ctdb_event_request_status)();
- TEST_FUNC(ctdb_event_request_script_enable)();
- TEST_FUNC(ctdb_event_request_script_disable)();
- TEST_FUNC(ctdb_event_reply_status)();
- TEST_FUNC(ctdb_event_reply_script_list)();
-
test_ctdb_rec_buffer_read_write();
return 0;
}
-
-#endif
#include <assert.h>
-#include <talloc.h>
+#include "protocol/protocol_basic.c"
+#include "protocol/protocol_types.c"
+#include "protocol/protocol_util.c"
-#include "protocol/protocol.h"
-#include "protocol/protocol_api.h"
#include "common/system_util.c"
/* Test parsing of IPs, conversion to string */
'comm_test',
'comm_server_test',
'comm_client_test',
- 'protocol_types_test',
- 'protocol_client_test',
'pidfile_test',
'run_proc_test',
'sock_daemon_test',
deps='samba-util ctdb-system popt',
install_path='${CTDB_TEST_LIBEXECDIR}')
+ bld.SAMBA_SUBSYSTEM('protocol-tests-common',
+ source=bld.SUBDIR('tests/src',
+ '''protocol_common.c
+ protocol_common_ctdb.c
+ protocol_common_event.c
+ '''),
+ includes='include',
+ deps='replace popt talloc tevent tdb')
+
+ ctdb_protocol_tests = [
+ 'protocol_basic_test',
+ 'protocol_types_test',
+ 'protocol_ctdb_test',
+ 'protocol_event_test',
+ 'protocol_util_test',
+ ]
+
+ for target in ctdb_protocol_tests:
+ src = 'tests/src/' + target + '.c'
+
+ bld.SAMBA_BINARY(target,
+ source=src,
+ deps='''protocol-tests-common
+ samba-util talloc tdb''',
+ install_path='${CTDB_TEST_LIBEXECDIR}')
bld.SAMBA_SUBSYSTEM('ctdb-tests-common',
source=bld.SUBDIR('tests/src',
includes='include',
deps='replace popt talloc tevent tdb')
- bld.SAMBA_BINARY('protocol_util_test',
- source='tests/src/protocol_util_test.c',
- deps='talloc ctdb-protocol samba-util',
- install_path='${CTDB_TEST_LIBEXECDIR}')
-
# Test binaries
ctdb_tests = [
'g_lock_loop',
git.samba.org / metze / samba / wip.git / commitdiff