ctdb/tests/src/protocol_common.h

   1 /*
   2    protocol tests - common functions
   3
   4    Copyright (C) Amitay Isaacs  2015-2017
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #ifndef __CTDB_PROTOCOL_COMMON_H__
  21 #define __CTDB_PROTOCOL_COMMON_H__
  22
  23 #include "replace.h"
  24 #include "system/network.h"
  25
  26 #include <talloc.h>
  27 #include <tdb.h>
  28
  29 #include "protocol/protocol.h"
  30
  31 /*
  32  * Generate test routines
  33  */
  34
  35 #define TEST_FUNC(NAME)         test_ ##NAME
  36 #define FILL_FUNC(NAME)         fill_ ##NAME
  37 #define VERIFY_FUNC(NAME)       verify_ ##NAME
  38 #define LEN_FUNC(NAME)          NAME## _len
  39 #define PUSH_FUNC(NAME)         NAME## _push
  40 #define PULL_FUNC(NAME)         NAME## _pull
  41
  42 /*
  43  * Test for basic data types that do not need memory allocation
  44  * For example - int32_t, uint32_t, uint64_t
  45  */
  46 #define PROTOCOL_TYPE1_TEST(TYPE, NAME) \
  47 static void TEST_FUNC(NAME)(void) \
  48 { \
  49         TYPE p1; \
  50         TYPE p2; \
  51         size_t buflen, np = 0; \
  52         int ret; \
  53 \
  54         FILL_FUNC(NAME)(&p1); \
  55         buflen = LEN_FUNC(NAME)(&p1); \
  56         assert(buflen < sizeof(BUFFER)); \
  57         PUSH_FUNC(NAME)(&p1, BUFFER, &np); \
  58         assert(np == buflen); \
  59         np = 0; \
  60         ret = PULL_FUNC(NAME)(BUFFER, buflen, &p2, &np); \
  61         assert(ret == 0); \
  62         assert(np == buflen); \
  63         VERIFY_FUNC(NAME)(&p1, &p2); \
  64 }
  65
  66 /*
  67  * Test for container data types that need memory allocation for sub-elements
  68  * For example - TDB_DATA
  69  */
  70 #define PROTOCOL_TYPE2_TEST(TYPE, NAME) \
  71 static void TEST_FUNC(NAME)(void) \
  72 { \
  73         TALLOC_CTX *mem_ctx; \
  74         TYPE p1; \
  75         TYPE p2; \
  76         size_t buflen, np = 0; \
  77         int ret; \
  78 \
  79         mem_ctx = talloc_new(NULL); \
  80         assert(mem_ctx != NULL); \
  81         FILL_FUNC(NAME)(mem_ctx, &p1); \
  82         buflen = LEN_FUNC(NAME)(&p1); \
  83         assert(buflen < sizeof(BUFFER)); \
  84         PUSH_FUNC(NAME)(&p1, BUFFER, &np); \
  85         assert(np == buflen); \
  86         np = 0; \
  87         ret = PULL_FUNC(NAME)(BUFFER, buflen, mem_ctx, &p2, &np); \
  88         assert(ret == 0); \
  89         assert(np == buflen); \
  90         VERIFY_FUNC(NAME)(&p1, &p2); \
  91         talloc_free(mem_ctx); \
  92 }
  93
  94 /*
  95  * Test for derived data types that need memory allocation
  96  * For example - most ctdb structures
  97  */
  98 #define PROTOCOL_TYPE3_TEST(TYPE, NAME) \
  99 static void TEST_FUNC(NAME)(void) \
 100 { \
 101         TALLOC_CTX *mem_ctx; \
 102         TYPE *p1, *p2; \
 103         size_t buflen, np = 0; \
 104         int ret; \
 105 \
 106         mem_ctx = talloc_new(NULL); \
 107         assert(mem_ctx != NULL); \
 108         p1 = talloc_zero(mem_ctx, TYPE); \
 109         assert(p1 != NULL); \
 110         FILL_FUNC(NAME)(p1, p1); \
 111         buflen = LEN_FUNC(NAME)(p1); \
 112         assert(buflen < sizeof(BUFFER)); \
 113         PUSH_FUNC(NAME)(p1, BUFFER, &np); \
 114         assert(np == buflen); \
 115         np = 0; \
 116         ret = PULL_FUNC(NAME)(BUFFER, buflen, mem_ctx, &p2, &np); \
 117         assert(ret == 0); \
 118         assert(np == buflen); \
 119         VERIFY_FUNC(NAME)(p1, p2); \
 120         talloc_free(mem_ctx); \
 121 }
 122
 123 extern uint8_t BUFFER[1024*1024];
 124
 125 int rand_int(int max);
 126 uint8_t rand8(void);
 127 uint16_t rand16(void);
 128 int32_t rand32i(void);
 129 uint32_t rand32(void);
 130 uint64_t rand64(void);
 131 double rand_double(void);
 132
 133 void fill_buffer(void *p, size_t len);
 134 void verify_buffer(void *p1, void *p2, size_t len);
 135
 136 void fill_ctdb_uint8(uint8_t *p);
 137 void verify_ctdb_uint8(uint8_t *p1, uint8_t *p2);
 138
 139 void fill_ctdb_uint16(uint16_t *p);
 140 void verify_ctdb_uint16(uint16_t *p1, uint16_t *p2);
 141
 142 void fill_ctdb_int32(int32_t *p);
 143 void verify_ctdb_int32(int32_t *p1, int32_t *p2);
 144
 145 void fill_ctdb_uint32(uint32_t *p);
 146 void verify_ctdb_uint32(uint32_t *p1, uint32_t *p2);
 147
 148 void fill_ctdb_uint64(uint64_t *p);
 149 void verify_ctdb_uint64(uint64_t *p1, uint64_t *p2);
 150
 151 void fill_ctdb_double(double *p);
 152 void verify_ctdb_double(double *p1, double *p2);
 153
 154 void fill_ctdb_bool(bool *p);
 155 void verify_ctdb_bool(bool *p1, bool *p2);
 156
 157 void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **p);
 158 void verify_ctdb_string(const char **p1, const char **p2);
 159
 160 void fill_ctdb_stringn(TALLOC_CTX *mem_ctx, const char **p);
 161 void verify_ctdb_stringn(const char **p1, const char **p2);
 162
 163 void fill_ctdb_pid(pid_t *p);
 164 void verify_ctdb_pid(pid_t *p1, pid_t *p2);
 165
 166 void fill_ctdb_timeval(struct timeval *p);
 167 void verify_ctdb_timeval(struct timeval *p1, struct timeval *p2);
 168
 169 void fill_tdb_data_nonnull(TALLOC_CTX *mem_ctx, TDB_DATA *p);
 170 void fill_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p);
 171 void verify_tdb_data(TDB_DATA *p1, TDB_DATA *p2);
 172
 173 void fill_ctdb_tdb_data(TALLOC_CTX *mem_ctx, TDB_DATA *p);
 174 void verify_ctdb_tdb_data(TDB_DATA *p1, TDB_DATA *p2);
 175
 176 void fill_ctdb_tdb_datan(TALLOC_CTX *mem_ctx, TDB_DATA *p);
 177 void verify_ctdb_tdb_datan(TDB_DATA *p1, TDB_DATA *p2);
 178
 179 void fill_ctdb_latency_counter(struct ctdb_latency_counter *p);
 180 void verify_ctdb_latency_counter(struct ctdb_latency_counter *p1,
 181                                  struct ctdb_latency_counter *p2);
 182
 183 void fill_ctdb_statistics(TALLOC_CTX *mem_ctx, struct ctdb_statistics *p);
 184 void verify_ctdb_statistics(struct ctdb_statistics *p1,
 185                             struct ctdb_statistics *p2);
 186
 187 void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p);
 188 void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1, struct ctdb_vnn_map *p2);
 189
 190 void fill_ctdb_dbid(TALLOC_CTX *mem_ctx, struct ctdb_dbid *p);
 191 void verify_ctdb_dbid(struct ctdb_dbid *p1, struct ctdb_dbid *p2);
 192
 193 void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p);
 194 void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1, struct ctdb_dbid_map *p2);
 195
 196 void fill_ctdb_pulldb(TALLOC_CTX *mem_ctx, struct ctdb_pulldb *p);
 197 void verify_ctdb_pulldb(struct ctdb_pulldb *p1, struct ctdb_pulldb *p2);
 198
 199 void fill_ctdb_pulldb_ext(TALLOC_CTX *mem_ctx, struct ctdb_pulldb_ext *p);
 200 void verify_ctdb_pulldb_ext(struct ctdb_pulldb_ext *p1,
 201                             struct ctdb_pulldb_ext *p2);
 202
 203 void fill_ctdb_ltdb_header(struct ctdb_ltdb_header *p);
 204 void verify_ctdb_ltdb_header(struct ctdb_ltdb_header *p1,
 205                              struct ctdb_ltdb_header *p2);
 206
 207 void fill_ctdb_rec_data(TALLOC_CTX *mem_ctx, struct ctdb_rec_data *p);
 208 void verify_ctdb_rec_data(struct ctdb_rec_data *p1, struct ctdb_rec_data *p2);
 209
 210 void fill_ctdb_rec_buffer(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *p);
 211 void verify_ctdb_rec_buffer(struct ctdb_rec_buffer *p1,
 212                             struct ctdb_rec_buffer *p2);
 213
 214 void fill_ctdb_traverse_start(TALLOC_CTX *mem_ctx,
 215                               struct ctdb_traverse_start *p);
 216 void verify_ctdb_traverse_start(struct ctdb_traverse_start *p1,
 217                                 struct ctdb_traverse_start *p2);
 218
 219 void fill_ctdb_traverse_all(TALLOC_CTX *mem_ctx,
 220                             struct ctdb_traverse_all *p);
 221 void verify_ctdb_traverse_all(struct ctdb_traverse_all *p1,
 222                               struct ctdb_traverse_all *p2);
 223
 224 void fill_ctdb_traverse_start_ext(TALLOC_CTX *mem_ctx,
 225                                   struct ctdb_traverse_start_ext *p);
 226 void verify_ctdb_traverse_start_ext(struct ctdb_traverse_start_ext *p1,
 227                                     struct ctdb_traverse_start_ext *p2);
 228
 229 void fill_ctdb_traverse_all_ext(TALLOC_CTX *mem_ctx,
 230                                 struct ctdb_traverse_all_ext *p);
 231 void verify_ctdb_traverse_all_ext(struct ctdb_traverse_all_ext *p1,
 232                                   struct ctdb_traverse_all_ext *p2);
 233
 234 void fill_ctdb_sock_addr(TALLOC_CTX *mem_ctx, ctdb_sock_addr *p);
 235 void verify_ctdb_sock_addr(ctdb_sock_addr *p1, ctdb_sock_addr *p2);
 236
 237 void fill_ctdb_connection(TALLOC_CTX *mem_ctx, struct ctdb_connection *p);
 238 void verify_ctdb_connection(struct ctdb_connection *p1,
 239                             struct ctdb_connection *p2);
 240
 241 void fill_ctdb_connection_list(TALLOC_CTX *mem_ctx,
 242                                struct ctdb_connection_list *p);
 243 void verify_ctdb_connection_list(struct ctdb_connection_list *p1,
 244                                  struct ctdb_connection_list *p2);
 245
 246 void fill_ctdb_tunable(TALLOC_CTX *mem_ctx, struct ctdb_tunable *p);
 247 void verify_ctdb_tunable(struct ctdb_tunable *p1, struct ctdb_tunable *p2);
 248
 249 void fill_ctdb_node_flag_change(TALLOC_CTX *mem_ctx,
 250                                 struct ctdb_node_flag_change *p);
 251 void verify_ctdb_node_flag_change(struct ctdb_node_flag_change *p1,
 252                                   struct ctdb_node_flag_change *p2);
 253
 254 void fill_ctdb_var_list(TALLOC_CTX *mem_ctx, struct ctdb_var_list *p);
 255 void verify_ctdb_var_list(struct ctdb_var_list *p1, struct ctdb_var_list *p2);
 256
 257 void fill_ctdb_tunable_list(TALLOC_CTX *mem_ctx, struct ctdb_tunable_list *p);
 258 void verify_ctdb_tunable_list(struct ctdb_tunable_list *p1,
 259                               struct ctdb_tunable_list *p2);
 260
 261 void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx, struct ctdb_tickle_list *p);
 262 void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
 263                              struct ctdb_tickle_list *p2);
 264
 265 void fill_ctdb_addr_info(TALLOC_CTX *mem_ctx, struct ctdb_addr_info *p);
 266 void verify_ctdb_addr_info(struct ctdb_addr_info *p1,
 267                            struct ctdb_addr_info *p2);
 268
 269 void fill_ctdb_transdb(TALLOC_CTX *mem_ctx, struct ctdb_transdb *p);
 270 void verify_ctdb_transdb(struct ctdb_transdb *p1, struct ctdb_transdb *p2);
 271
 272 void fill_ctdb_uptime(TALLOC_CTX *mem_ctx, struct ctdb_uptime *p);
 273 void verify_ctdb_uptime(struct ctdb_uptime *p1, struct ctdb_uptime *p2);
 274
 275 void fill_ctdb_public_ip(TALLOC_CTX *mem_ctx, struct ctdb_public_ip *p);
 276 void verify_ctdb_public_ip(struct ctdb_public_ip *p1,
 277                            struct ctdb_public_ip *p2);
 278
 279 void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
 280                               struct ctdb_public_ip_list *p);
 281 void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
 282                                 struct ctdb_public_ip_list *p2);
 283
 284 void fill_ctdb_node_and_flags(TALLOC_CTX *mem_ctx,
 285                               struct ctdb_node_and_flags *p);
 286 void verify_ctdb_node_and_flags(struct ctdb_node_and_flags *p1,
 287                                 struct ctdb_node_and_flags *p2);
 288
 289 void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p);
 290 void verify_ctdb_node_map(struct ctdb_node_map *p1, struct ctdb_node_map *p2);
 291
 292 void fill_ctdb_script(TALLOC_CTX *mem_ctx, struct ctdb_script *p);
 293 void verify_ctdb_script(struct ctdb_script *p1, struct ctdb_script *p2);
 294
 295 void fill_ctdb_script_list(TALLOC_CTX *mem_ctx, struct ctdb_script_list *p);
 296 void verify_ctdb_script_list(struct ctdb_script_list *p1,
 297                              struct ctdb_script_list *p2);
 298
 299 void fill_ctdb_ban_state(TALLOC_CTX *mem_ctx, struct ctdb_ban_state *p);
 300 void verify_ctdb_ban_state(struct ctdb_ban_state *p1,
 301                            struct ctdb_ban_state *p2);
 302
 303 void fill_ctdb_notify_data(TALLOC_CTX *mem_ctx, struct ctdb_notify_data *p);
 304 void verify_ctdb_notify_data(struct ctdb_notify_data *p1,
 305                              struct ctdb_notify_data *p2);
 306
 307 void fill_ctdb_iface(TALLOC_CTX *mem_ctx, struct ctdb_iface *p);
 308 void verify_ctdb_iface(struct ctdb_iface *p1, struct ctdb_iface *p2);
 309
 310 void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx, struct ctdb_iface_list *p);
 311 void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
 312                             struct ctdb_iface_list *p2);
 313
 314 void fill_ctdb_public_ip_info(TALLOC_CTX *mem_ctx,
 315                               struct ctdb_public_ip_info *p);
 316 void verify_ctdb_public_ip_info(struct ctdb_public_ip_info *p1,
 317                                 struct ctdb_public_ip_info *p2);
 318
 319 void fill_ctdb_statistics_list(TALLOC_CTX *mem_ctx,
 320                                struct ctdb_statistics_list *p);
 321 void verify_ctdb_statistics_list(struct ctdb_statistics_list *p1,
 322                                  struct ctdb_statistics_list *p2);
 323
 324 void fill_ctdb_key_data(TALLOC_CTX *mem_ctx, struct ctdb_key_data *p);
 325 void verify_ctdb_key_data(struct ctdb_key_data *p1, struct ctdb_key_data *p2);
 326
 327 void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
 328                              struct ctdb_db_statistics *p);
 329 void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
 330                                struct ctdb_db_statistics *p2);
 331
 332 void fill_ctdb_election_message(TALLOC_CTX *mem_ctx,
 333                                 struct ctdb_election_message *p);
 334 void verify_ctdb_election_message(struct ctdb_election_message *p1,
 335                                   struct ctdb_election_message *p2);
 336
 337 void fill_ctdb_srvid_message(TALLOC_CTX *mem_ctx,
 338                              struct ctdb_srvid_message *p);
 339 void verify_ctdb_srvid_message(struct ctdb_srvid_message *p1,
 340                                struct ctdb_srvid_message *p2);
 341
 342 void fill_ctdb_disable_message(TALLOC_CTX *mem_ctx,
 343                                struct ctdb_disable_message *p);
 344 void verify_ctdb_disable_message(struct ctdb_disable_message *p1,
 345                                  struct ctdb_disable_message *p2);
 346
 347 void fill_ctdb_server_id(struct ctdb_server_id *p);
 348 void verify_ctdb_server_id(struct ctdb_server_id *p1,
 349                            struct ctdb_server_id *p2);
 350
 351 void fill_ctdb_g_lock(struct ctdb_g_lock *p);
 352 void verify_ctdb_g_lock(struct ctdb_g_lock *p1, struct ctdb_g_lock *p2);
 353
 354 void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx, struct ctdb_g_lock_list *p);
 355 void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
 356                              struct ctdb_g_lock_list *p2);
 357
 358 void fill_sock_packet_header(struct sock_packet_header *p);
 359 void verify_sock_packet_header(struct sock_packet_header *p1,
 360                                struct sock_packet_header *p2);
 361
 362 #endif /* __CTDB_PROTOCOL_COMMON_H__ */