ctdb/protocol/protocol_debug.c

   1 /*
   2    CTDB protocol marshalling
   3
   4    Copyright (C) Amitay Isaacs  2016
   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 #include "replace.h"
  21 #include "system/network.h"
  22 #include "system/locale.h"
  23
  24 #include <talloc.h>
  25 #include <tdb.h>
  26
  27 #include <protocol/protocol.h>
  28 #include <protocol/protocol_api.h>
  29
  30 /*
  31  * Utility functions
  32  */
  33 struct uint32_map {
  34         uint32_t key;
  35 #define MAP_END         0xffffffff
  36         const char *name;
  37 };
  38
  39
  40 static void uint32_map_print(struct uint32_map *map, uint32_t key, FILE *fp)
  41 {
  42         int i = 0;
  43
  44         while (map[i].key != MAP_END) {
  45                 if (key == map[i].key) {
  46                         fprintf(fp, "%s", map[i].name);
  47                         return;
  48                 }
  49                 i = i+1;
  50         }
  51
  52         fprintf(fp, "UNKNOWN(%u)", key);
  53 }
  54
  55 static void tdb_data_print(TDB_DATA d, FILE *fp)
  56 {
  57         unsigned char *p = (unsigned char *)d.dptr;
  58         int len = d.dsize;
  59         while (len--) {
  60                 if (isprint(*p) && !strchr("\"\\", *p)) {
  61                         fputc(*p, fp);
  62                 } else {
  63                         fprintf(fp, "\\%02X", *p);
  64                 }
  65                 p++;
  66         }
  67 }
  68
  69 /*
  70  * Data types
  71  */
  72
  73 static void ctdb_operation_print(uint32_t operation, FILE *fp)
  74 {
  75         struct uint32_map map[] = {
  76                 { CTDB_REQ_CALL, "REQ_CALL" },
  77                 { CTDB_REPLY_CALL, "REPLY_CALL" },
  78                 { CTDB_REQ_DMASTER, "REQ_DMASTER" },
  79                 { CTDB_REPLY_DMASTER, "REPLY_DMASTER" },
  80                 { CTDB_REPLY_ERROR, "REPLY_ERROR" },
  81                 { CTDB_REQ_MESSAGE, "REQ_MESSAGE" },
  82                 { CTDB_REQ_CONTROL, "REQ_CONTROL", },
  83                 { CTDB_REPLY_CONTROL, "REPLY_CONTROL" },
  84                 { CTDB_REQ_KEEPALIVE, "REQ_KEEPALIVE" },
  85                 { MAP_END, "" },
  86         };
  87
  88         uint32_map_print(map, operation, fp);
  89 }
  90
  91 static void ctdb_callid_print(uint32_t callid, FILE *fp)
  92 {
  93         struct uint32_map map[] = {
  94                 { CTDB_NULL_FUNC, "NULL" },
  95                 { CTDB_FETCH_FUNC, "FETCH" },
  96                 { CTDB_FETCH_WITH_HEADER_FUNC, "FETCH_WITH_HEADER" },
  97                 { MAP_END, "" },
  98         };
  99
 100         uint32_map_print(map, callid, fp);
 101 }
 102
 103 static void ctdb_opcode_print(uint32_t opcode, FILE *fp)
 104 {
 105         struct uint32_map map[] = {
 106                 { CTDB_CONTROL_PROCESS_EXISTS, "PROCESS_EXISTS" },
 107                 { CTDB_CONTROL_STATISTICS, "STATISTICS" },
 108                 { CTDB_CONTROL_PING, "PING" },
 109                 { CTDB_CONTROL_GETDBPATH, "GETDBPATH" },
 110                 { CTDB_CONTROL_GETVNNMAP, "GETVNNMAP" },
 111                 { CTDB_CONTROL_SETVNNMAP, "SETVNNMAP" },
 112                 { CTDB_CONTROL_GET_DEBUG, "GET_DEBUG" },
 113                 { CTDB_CONTROL_SET_DEBUG, "SET_DEBUG" },
 114                 { CTDB_CONTROL_GET_DBMAP, "GET_DBMAP" },
 115                 { CTDB_CONTROL_GET_NODEMAPv4, "GET_NODEMAPv4" },
 116                 { CTDB_CONTROL_SET_DMASTER, "SET_DMASTER" },
 117                 { CTDB_CONTROL_GET_RECMODE, "GET_RECMODE" },
 118                 { CTDB_CONTROL_SET_RECMODE, "SET_RECMODE" },
 119                 { CTDB_CONTROL_STATISTICS_RESET, "STATISTICS_RESET" },
 120                 { CTDB_CONTROL_DB_ATTACH, "DB_ATTACH" },
 121                 { CTDB_CONTROL_SET_CALL, "SET_CALL" },
 122                 { CTDB_CONTROL_TRAVERSE_START, "TRAVERSE_START" },
 123                 { CTDB_CONTROL_TRAVERSE_ALL, "TRAVERSE_ALL" },
 124                 { CTDB_CONTROL_TRAVERSE_DATA, "TRAVERSE_DATA" },
 125                 { CTDB_CONTROL_REGISTER_SRVID, "REGISTER_SRVID" },
 126                 { CTDB_CONTROL_DEREGISTER_SRVID, "DEREGISTER_SRVID" },
 127                 { CTDB_CONTROL_GET_DBNAME, "GET_DBNAME" },
 128                 { CTDB_CONTROL_ENABLE_SEQNUM, "ENABLE_SEQNUM" },
 129                 { CTDB_CONTROL_UPDATE_SEQNUM, "UPDATE_SEQNUM" },
 130                 { CTDB_CONTROL_DUMP_MEMORY, "DUMP_MEMORY" },
 131                 { CTDB_CONTROL_GET_PID, "GET_PID" },
 132                 { CTDB_CONTROL_GET_RECMASTER, "GET_RECMASTER" },
 133                 { CTDB_CONTROL_SET_RECMASTER, "SET_RECMASTER" },
 134                 { CTDB_CONTROL_FREEZE, "FREEZE" },
 135                 { CTDB_CONTROL_THAW, "THAW" },
 136                 { CTDB_CONTROL_GET_PNN, "GET_PNN" },
 137                 { CTDB_CONTROL_SHUTDOWN, "SHUTDOWN" },
 138                 { CTDB_CONTROL_GET_MONMODE, "GET_MONMODE" },
 139                 { CTDB_CONTROL_TAKEOVER_IPv4, "TAKEOVER_IPv4" },
 140                 { CTDB_CONTROL_RELEASE_IPv4, "RELEASE_IPv4" },
 141                 { CTDB_CONTROL_TCP_CLIENT, "TCP_CLIENT" },
 142                 { CTDB_CONTROL_TCP_ADD, "TCP_ADD" },
 143                 { CTDB_CONTROL_TCP_REMOVE, "TCP_REMOVE" },
 144                 { CTDB_CONTROL_STARTUP, "STARTUP" },
 145                 { CTDB_CONTROL_SET_TUNABLE, "SET_TUNABLE" },
 146                 { CTDB_CONTROL_GET_TUNABLE, "GET_TUNABLE" },
 147                 { CTDB_CONTROL_LIST_TUNABLES, "LIST_TUNABLES" },
 148                 { CTDB_CONTROL_GET_PUBLIC_IPSv4, "GET_PUBLIC_IPSv4" },
 149                 { CTDB_CONTROL_MODIFY_FLAGS, "MODIFY_FLAGS" },
 150                 { CTDB_CONTROL_GET_ALL_TUNABLES, "GET_ALL_TUNABLES" },
 151                 { CTDB_CONTROL_KILL_TCP, "KILL_TCP" },
 152                 { CTDB_CONTROL_GET_TCP_TICKLE_LIST, "GET_TCP_TICKLE_LIST" },
 153                 { CTDB_CONTROL_SET_TCP_TICKLE_LIST, "SET_TCP_TICKLE_LIST" },
 154                 { CTDB_CONTROL_REGISTER_SERVER_ID, "REGISTER_SERVER_ID" },
 155                 { CTDB_CONTROL_UNREGISTER_SERVER_ID, "UNREGISTER_SERVER_ID" },
 156                 { CTDB_CONTROL_CHECK_SERVER_ID, "CHECK_SERVER_ID" },
 157                 { CTDB_CONTROL_GET_SERVER_ID_LIST, "GET_SERVER_ID_LIST" },
 158                 { CTDB_CONTROL_DB_ATTACH_PERSISTENT, "DB_ATTACH_PERSISTENT" },
 159                 { CTDB_CONTROL_PERSISTENT_STORE, "PERSISTENT_STORE" },
 160                 { CTDB_CONTROL_UPDATE_RECORD, "UPDATE_RECORD" },
 161                 { CTDB_CONTROL_SEND_GRATUITOUS_ARP, "SEND_GRATUITOUS_ARP" },
 162                 { CTDB_CONTROL_TRANSACTION_START, "TRANSACTION_START" },
 163                 { CTDB_CONTROL_TRANSACTION_COMMIT, "TRANSACTION_COMMIT" },
 164                 { CTDB_CONTROL_WIPE_DATABASE, "WIPE_DATABASE" },
 165                 { CTDB_CONTROL_UPTIME, "UPTIME" },
 166                 { CTDB_CONTROL_START_RECOVERY, "START_RECOVERY" },
 167                 { CTDB_CONTROL_END_RECOVERY, "END_RECOVERY" },
 168                 { CTDB_CONTROL_RELOAD_NODES_FILE, "RELOAD_NODES_FILE" },
 169                 { CTDB_CONTROL_TRY_DELETE_RECORDS, "TRY_DELETE_RECORDS" },
 170                 { CTDB_CONTROL_ENABLE_MONITOR, "ENABLE_MONITOR" },
 171                 { CTDB_CONTROL_DISABLE_MONITOR, "DISABLE_MONITOR" },
 172                 { CTDB_CONTROL_ADD_PUBLIC_IP, "ADD_PUBLIC_IP" },
 173                 { CTDB_CONTROL_DEL_PUBLIC_IP, "DEL_PUBLIC_IP" },
 174                 { CTDB_CONTROL_RUN_EVENTSCRIPTS, "RUN_EVENTSCRIPTS" },
 175                 { CTDB_CONTROL_GET_CAPABILITIES, "GET_CAPABILITIES" },
 176                 { CTDB_CONTROL_START_PERSISTENT_UPDATE, "START_PERSISTENT_UPDATE" },
 177                 { CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE, "CANCEL_PERSISTENT_UPDATE" },
 178                 { CTDB_CONTROL_TRANS2_COMMIT, "TRANS2_COMMIT" },
 179                 { CTDB_CONTROL_TRANS2_FINISHED, "TRANS2_FINISHED" },
 180                 { CTDB_CONTROL_TRANS2_ERROR, "TRANS2_ERROR" },
 181                 { CTDB_CONTROL_TRANS2_COMMIT_RETRY, "TRANS2_COMMIT_RETRY" },
 182                 { CTDB_CONTROL_RECD_PING, "RECD_PING" },
 183                 { CTDB_CONTROL_RELEASE_IP, "RELEASE_IP" },
 184                 { CTDB_CONTROL_TAKEOVER_IP, "TAKEOVER_IP" },
 185                 { CTDB_CONTROL_GET_PUBLIC_IPS, "GET_PUBLIC_IPS" },
 186                 { CTDB_CONTROL_GET_NODEMAP, "GET_NODEMAP" },
 187                 { CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS, "GET_EVENT_SCRIPT_STATUS" },
 188                 { CTDB_CONTROL_TRAVERSE_KILL, "TRAVERSE_KILL" },
 189                 { CTDB_CONTROL_RECD_RECLOCK_LATENCY, "RECD_RECLOCK_LATENCY" },
 190                 { CTDB_CONTROL_GET_RECLOCK_FILE, "GET_RECLOCK_FILE" },
 191                 { CTDB_CONTROL_STOP_NODE, "STOP_NODE" },
 192                 { CTDB_CONTROL_CONTINUE_NODE, "CONTINUE_NODE" },
 193                 { CTDB_CONTROL_SET_NATGWSTATE, "SET_NATGWSTATE" },
 194                 { CTDB_CONTROL_SET_LMASTERROLE, "SET_LMASTERROLE" },
 195                 { CTDB_CONTROL_SET_RECMASTERROLE, "SET_RECMASTERROLE" },
 196                 { CTDB_CONTROL_ENABLE_SCRIPT, "ENABLE_SCRIPT" },
 197                 { CTDB_CONTROL_DISABLE_SCRIPT, "DISABLE_SCRIPT" },
 198                 { CTDB_CONTROL_SET_BAN_STATE, "SET_BAN_STATE" },
 199                 { CTDB_CONTROL_GET_BAN_STATE, "GET_BAN_STATE" },
 200                 { CTDB_CONTROL_SET_DB_PRIORITY, "SET_DB_PRIORITY" },
 201                 { CTDB_CONTROL_GET_DB_PRIORITY, "GET_DB_PRIORITY" },
 202                 { CTDB_CONTROL_TRANSACTION_CANCEL, "TRANSACTION_CANCEL" },
 203                 { CTDB_CONTROL_REGISTER_NOTIFY, "REGISTER_NOTIFY" },
 204                 { CTDB_CONTROL_DEREGISTER_NOTIFY, "DEREGISTER_NOTIFY" },
 205                 { CTDB_CONTROL_TRANS2_ACTIVE, "TRANS2_ACTIVE" },
 206                 { CTDB_CONTROL_GET_LOG, "GET_LOG" },
 207                 { CTDB_CONTROL_CLEAR_LOG, "CLEAR_LOG" },
 208                 { CTDB_CONTROL_TRANS3_COMMIT, "TRANS3_COMMIT" },
 209                 { CTDB_CONTROL_GET_DB_SEQNUM, "GET_DB_SEQNUM" },
 210                 { CTDB_CONTROL_DB_SET_HEALTHY, "DB_SET_HEALTHY" },
 211                 { CTDB_CONTROL_DB_GET_HEALTH, "DB_GET_HEALTH" },
 212                 { CTDB_CONTROL_GET_PUBLIC_IP_INFO, "GET_PUBLIC_IP_INFO" },
 213                 { CTDB_CONTROL_GET_IFACES, "GET_IFACES" },
 214                 { CTDB_CONTROL_SET_IFACE_LINK_STATE, "SET_IFACE_LINK_STATE" },
 215                 { CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE, "TCP_ADD_DELAYED_UPDATE" },
 216                 { CTDB_CONTROL_GET_STAT_HISTORY, "GET_STAT_HISTORY" },
 217                 { CTDB_CONTROL_SCHEDULE_FOR_DELETION, "SCHEDULE_FOR_DELETION" },
 218                 { CTDB_CONTROL_SET_DB_READONLY, "SET_DB_READONLY" },
 219                 { CTDB_CONTROL_CHECK_SRVIDS, "CHECK_SRVIDS" },
 220                 { CTDB_CONTROL_TRAVERSE_START_EXT, "TRAVERSE_START_EXT" },
 221                 { CTDB_CONTROL_GET_DB_STATISTICS, "GET_DB_STATISTICS" },
 222                 { CTDB_CONTROL_SET_DB_STICKY, "SET_DB_STICKY" },
 223                 { CTDB_CONTROL_RELOAD_PUBLIC_IPS, "RELOAD_PUBLIC_IPS" },
 224                 { CTDB_CONTROL_TRAVERSE_ALL_EXT, "TRAVERSE_ALL_EXT" },
 225                 { CTDB_CONTROL_RECEIVE_RECORDS, "RECEIVE_RECORDS" },
 226                 { CTDB_CONTROL_IPREALLOCATED, "IPREALLOCATED" },
 227                 { CTDB_CONTROL_GET_RUNSTATE, "GET_RUNSTATE" },
 228                 { CTDB_CONTROL_DB_DETACH, "DB_DETACH" },
 229                 { CTDB_CONTROL_GET_NODES_FILE, "GET_NODES_FILE" },
 230                 { CTDB_CONTROL_DB_FREEZE, "DB_FREEZE" },
 231                 { CTDB_CONTROL_DB_THAW, "DB_THAW" },
 232                 { CTDB_CONTROL_DB_TRANSACTION_START, "DB_TRANSACTION_START" },
 233                 { CTDB_CONTROL_DB_TRANSACTION_COMMIT, "DB_TRANSACTION_COMMIT" },
 234                 { CTDB_CONTROL_DB_TRANSACTION_CANCEL, "DB_TRANSACTION_CANCEL" },
 235                 { CTDB_CONTROL_DB_PULL, "DB_PULL" },
 236                 { CTDB_CONTROL_DB_PUSH_START, "DB_PUSH_START" },
 237                 { CTDB_CONTROL_DB_PUSH_CONFIRM, "DB_PUSH_CONFIRM" },
 238                 { CTDB_CONTROL_DB_OPEN_FLAGS, "DB_OPEN_FLAGS" },
 239                 { CTDB_CONTROL_DB_ATTACH_REPLICATED, "DB_ATTACH_REPLICATED" },
 240                 { CTDB_CONTROL_CHECK_PID_SRVID, "CHECK_PID_SRVID" },
 241                 { CTDB_CONTROL_TUNNEL_REGISTER, "TUNNEL_REGISTER" },
 242                 { CTDB_CONTROL_TUNNEL_DEREGISTER, "TUNNEL_DEREGISTER" },
 243                 { CTDB_CONTROL_VACUUM_FETCH, "VACUUM_FETCH" },
 244                 { CTDB_CONTROL_DB_VACUUM, "DB_VACUUM" },
 245                 { CTDB_CONTROL_ECHO_DATA, "ECHO_DATA" },
 246                 { CTDB_CONTROL_DISABLE_NODE, "DISABLE_NODE" },
 247                 { CTDB_CONTROL_ENABLE_NODE, "ENABLE_NODE" },
 248                 { CTDB_CONTROL_TCP_CLIENT_DISCONNECTED, "TCP_CLIENT_DISCONNECTED" },
 249                 { CTDB_CONTROL_TCP_CLIENT_PASSED, "TCP_CLIENT_PASSED" },
 250                 { CTDB_CONTROL_START_IPREALLOCATE, "START_IPREALLOCATE" },
 251                 { MAP_END, "" },
 252         };
 253
 254         uint32_map_print(map, opcode, fp);
 255 }
 256
 257 static void ctdb_control_flags_print(uint32_t flags, FILE *fp)
 258 {
 259         if (flags & CTDB_CTRL_FLAG_NOREPLY) {
 260                 fprintf(fp, "NOREPLY ");
 261         }
 262         if (flags & CTDB_CTRL_FLAG_OPCODE_SPECIFIC) {
 263                 fprintf(fp, "OPCODE_SPECIFIC ");
 264         }
 265 }
 266
 267 static void ctdb_pnn_print(uint32_t pnn, FILE *fp)
 268 {
 269         if (pnn == CTDB_CURRENT_NODE) {
 270                 fprintf(fp, "CURRENT");
 271         } else if (pnn == CTDB_BROADCAST_ALL) {
 272                 fprintf(fp, "ALL");
 273         } else if (pnn == CTDB_BROADCAST_ACTIVE) {
 274                 fprintf(fp, "ACTIVE");
 275         } else  if (pnn == CTDB_BROADCAST_CONNECTED) {
 276                 fprintf(fp, "CONNECTED");
 277         } else if (pnn == CTDB_MULTICAST) {
 278                 fprintf(fp, "MULTICAST");
 279         } else if (pnn == CTDB_UNKNOWN_PNN) {
 280                 fprintf(fp, "UNKNOWN");
 281         } else {
 282                 fprintf(fp, "%u", pnn);
 283         }
 284 }
 285
 286 static void ctdb_srvid_print(uint64_t srvid, FILE *fp)
 287 {
 288         uint64_t prefix = 0xFFFF000000000000LL;
 289
 290         if (srvid == CTDB_SRVID_ALL) {
 291                 fprintf(fp, "ALL");
 292         } else if ((srvid & prefix) == CTDB_SRVID_RECOVERY) {
 293                 srvid = srvid & ~CTDB_SRVID_RECOVERY;
 294                 fprintf(fp, "RECOVERY-%"PRIx64"", srvid);
 295         } else if (srvid == CTDB_SRVID_BANNING) {
 296                 fprintf(fp, "BANNING");
 297         } else if (srvid == CTDB_SRVID_ELECTION) {
 298                 fprintf(fp, "ELECTION");
 299         } else if (srvid == CTDB_SRVID_RECONFIGURE) {
 300                 fprintf(fp, "RECONFIGURE");
 301         } else if (srvid == CTDB_SRVID_RELEASE_IP) {
 302                 fprintf(fp, "RELEASE_IP");
 303         } else if (srvid == CTDB_SRVID_TAKE_IP) {
 304                 fprintf(fp, "TAKE_IP");
 305         } else if (srvid == CTDB_SRVID_IPREALLOCATED) {
 306                 fprintf(fp, "IPREALLOCATED");
 307         } else if (srvid == CTDB_SRVID_START_IPREALLOCATE) {
 308                 fprintf(fp, "START_IPREALLOCATE");
 309         } else if (srvid == CTDB_SRVID_SET_NODE_FLAGS) {
 310                 fprintf(fp, "SET_NODE_FLAGS");
 311         } else if (srvid == CTDB_SRVID_RECD_UPDATE_IP) {
 312                 fprintf(fp, "RECD_UPDATE_IP");
 313         } else if (srvid == CTDB_SRVID_VACUUM_FETCH) {
 314                 fprintf(fp, "VACUUM_FETCH");
 315         } else if (srvid == CTDB_SRVID_DETACH_DATABASE) {
 316                 fprintf(fp, "DETACH_DATABASE");
 317         } else if (srvid == CTDB_SRVID_MEM_DUMP) {
 318                 fprintf(fp, "MEM_DUMP");
 319         } else if (srvid == CTDB_SRVID_GETLOG) {
 320                 fprintf(fp, "GETLOG");
 321         } else if (srvid == CTDB_SRVID_CLEARLOG) {
 322                 fprintf(fp, "CLEARLOG");
 323         } else if (srvid == CTDB_SRVID_PUSH_NODE_FLAGS) {
 324                 fprintf(fp, "PUSH_NODE_FLAGS");
 325         } else if (srvid == CTDB_SRVID_RELOAD_NODES) {
 326                 fprintf(fp, "RELOAD_NODES");
 327         } else if (srvid == CTDB_SRVID_TAKEOVER_RUN) {
 328                 fprintf(fp, "TAKEOVER_RUN");
 329         } else if (srvid == CTDB_SRVID_REBALANCE_NODE) {
 330                 fprintf(fp, "REBALANCE_NODE");
 331         } else if (srvid == CTDB_SRVID_DISABLE_TAKEOVER_RUNS) {
 332                 fprintf(fp, "DISABLE_TAKEOVER_RUNS");
 333         } else if (srvid == CTDB_SRVID_DISABLE_RECOVERIES) {
 334                 fprintf(fp, "DISABLE_RECOVERIES");
 335         } else if (srvid == CTDB_SRVID_DISABLE_IP_CHECK) {
 336                 fprintf(fp, "DISABLE_IP_CHECK");
 337         } else if ((srvid & prefix) == CTDB_SRVID_SAMBA_RANGE) {
 338                 if (srvid == CTDB_SRVID_SAMBA_NOTIFY) {
 339                         fprintf(fp, "SAMBA_NOTIFY");
 340                 } else {
 341                         srvid &= ~CTDB_SRVID_SAMBA_RANGE;
 342                         fprintf(fp, "samba-0x%"PRIx64"", srvid);
 343                 }
 344         } else if ((srvid & prefix) == CTDB_SRVID_NFSD_RANGE) {
 345                 srvid &= ~CTDB_SRVID_NFSD_RANGE;
 346                 fprintf(fp, "nfsd-0x%"PRIx64"", srvid);
 347         } else if ((srvid & prefix) == CTDB_SRVID_ISCSID_RANGE) {
 348                 srvid &= ~CTDB_SRVID_ISCSID_RANGE;
 349                 fprintf(fp, "iscsi-0x%"PRIx64"", srvid);
 350         } else if ((srvid & prefix) == CTDB_SRVID_TOOL_RANGE) {
 351                 srvid &= ~CTDB_SRVID_TOOL_RANGE;
 352                 fprintf(fp, "tool-0x%"PRIx64"", srvid);
 353         } else if ((srvid & prefix) == CTDB_SRVID_TEST_RANGE) {
 354                 srvid &= ~CTDB_SRVID_TEST_RANGE;
 355                 fprintf(fp, "test-0x%"PRIx64"", srvid);
 356         } else if ((srvid & prefix) == CTDB_SRVID_PID_RANGE) {
 357                 if (srvid < UINT16_MAX) {
 358                         fprintf(fp, "pid-%"PRIu64, srvid);
 359                 } else {
 360                         fprintf(fp, "pid-0x%"PRIx64, srvid);
 361                 }
 362         } else {
 363                 fprintf(fp, "0x%"PRIx64, srvid);
 364         }
 365 }
 366
 367 static void ctdb_tunnel_id_print(uint64_t tunnel_id, FILE *fp)
 368 {
 369         if ((tunnel_id & CTDB_TUNNEL_TEST) == CTDB_TUNNEL_TEST) {
 370                 fprintf(fp, "TEST-%"PRIx64, tunnel_id);
 371         } else {
 372                 fprintf(fp, "0x%"PRIx64, tunnel_id);
 373         }
 374 }
 375
 376 static void ctdb_tunnel_flags_print(uint32_t flags, FILE *fp)
 377 {
 378         if (flags & CTDB_TUNNEL_FLAG_REQUEST) {
 379                 fprintf(fp, "REQUEST ");
 380         }
 381         if (flags & CTDB_TUNNEL_FLAG_REPLY) {
 382                 fprintf(fp, "REPLY ");
 383         }
 384         if (flags & CTDB_TUNNEL_FLAG_NOREPLY) {
 385                 fprintf(fp, "NOREPLY ");
 386         }
 387 }
 388
 389 /*
 390  * Print routines
 391  */
 392
 393 static void ctdb_req_header_print(struct ctdb_req_header *h, FILE *fp)
 394 {
 395         fprintf(fp, "Header\n");
 396         fprintf(fp, "  length:%u magic:0x%"PRIx32" version:%u generation:0x%"PRIx32"\n",
 397                 h->length, h->ctdb_magic, h->ctdb_version, h->generation);
 398         fprintf(fp, "  ");
 399         ctdb_operation_print(h->operation, fp);
 400         fprintf(fp, " dst:");
 401         ctdb_pnn_print(h->destnode, fp);
 402         fprintf(fp, " src:");
 403         ctdb_pnn_print(h->srcnode, fp);
 404         fprintf(fp, " reqid:0x%"PRIx32"\n", h->reqid);
 405 }
 406
 407 static void ctdb_req_call_print(struct ctdb_req_call *c, FILE *fp)
 408 {
 409         fprintf(fp, "Data\n");
 410         fprintf(fp, "  db:0x%"PRIx32" ", c->db_id);
 411         ctdb_callid_print(c->callid, fp);
 412         fprintf(fp, "\n");
 413         fprintf(fp, "  key:");
 414         tdb_data_print(c->key, fp);
 415         fprintf(fp, "\n");
 416 }
 417
 418 static void ctdb_reply_call_print(struct ctdb_reply_call *c, FILE *fp)
 419 {
 420         fprintf(fp, "Data\n");
 421         fprintf(fp, "  status:%d\n", c->status);
 422         if (c->status == 0) {
 423                 fprintf(fp, "  data:");
 424                 tdb_data_print(c->data, fp);
 425                 fprintf(fp, "\n");
 426         }
 427 }
 428
 429 static void ctdb_req_dmaster_print(struct ctdb_req_dmaster *c, FILE *fp)
 430 {
 431         fprintf(fp, "Data\n");
 432         fprintf(fp, "  db:0x%"PRIx32" rsn:0x%"PRIx64" dmaster:%u\n",
 433                 c->db_id, c->rsn, c->dmaster);
 434         fprintf(fp, "  key:");
 435         tdb_data_print(c->key, fp);
 436         fprintf(fp, "\n");
 437         fprintf(fp, "  data:");
 438         tdb_data_print(c->data, fp);
 439         fprintf(fp, "\n");
 440 }
 441
 442 static void ctdb_reply_dmaster_print(struct ctdb_reply_dmaster *c, FILE *fp)
 443 {
 444         fprintf(fp, "Data\n");
 445         fprintf(fp, "  db:0x%"PRIx32" rsn:0x%"PRIx64"\n", c->db_id, c->rsn);
 446         fprintf(fp, "  key:");
 447         tdb_data_print(c->key, fp);
 448         fprintf(fp, "\n");
 449         fprintf(fp, "  data:");
 450         tdb_data_print(c->data, fp);
 451         fprintf(fp, "\n");
 452 }
 453
 454 static void ctdb_reply_error_print(struct ctdb_reply_error *c, FILE *fp)
 455 {
 456         fprintf(fp, "Data\n");
 457         fprintf(fp, "  status:%d\n", c->status);
 458         if (c->status != 0) {
 459                 fprintf(fp, "  msg:");
 460                 tdb_data_print(c->msg, fp);
 461                 fprintf(fp, "\n");
 462         }
 463 }
 464
 465 static void ctdb_req_message_data_print(struct ctdb_req_message_data *c,
 466                                         FILE *fp)
 467 {
 468         fprintf(fp, "Data\n");
 469         fprintf(fp, "  srvid:");
 470         ctdb_srvid_print(c->srvid, fp);
 471         fprintf(fp, "\n");
 472         fprintf(fp, "  data:");
 473         tdb_data_print(c->data, fp);
 474         fprintf(fp, "\n");
 475 }
 476
 477 static void ctdb_req_control_print(struct ctdb_req_control *c, FILE *fp)
 478 {
 479         fprintf(fp, "Data\n");
 480         fprintf(fp, "  ");
 481         ctdb_opcode_print(c->opcode, fp);
 482         fprintf(fp, " srvid:");
 483         ctdb_srvid_print(c->srvid, fp);
 484         fprintf(fp, " client_id:0x%"PRIx32" ", c->client_id);
 485         ctdb_control_flags_print(c->flags, fp);
 486         fprintf(fp, "\n");
 487 }
 488
 489 static void ctdb_reply_control_print(struct ctdb_reply_control *c, FILE *fp)
 490 {
 491         fprintf(fp, "Data\n");
 492         fprintf(fp, "  status:%d ", c->status);
 493         if (c->errmsg != NULL) {
 494                 fprintf(fp, "errmsg: %s", c->errmsg);
 495         }
 496         fprintf(fp, "\n");
 497 }
 498
 499 static void ctdb_req_keepalive_print(struct ctdb_req_keepalive *c, FILE *fp)
 500 {
 501         fprintf(fp, "Data\n");
 502         fprintf(fp, "  version:0x%"PRIx32, c->version);
 503         fprintf(fp, "  uptime:%"PRIu32, c->uptime);
 504         fprintf(fp, "\n");
 505 }
 506
 507 static void ctdb_req_tunnel_print(struct ctdb_req_tunnel *c, FILE *fp)
 508 {
 509         fprintf(fp, "Data\n");
 510         fprintf(fp, "  tunnel_id:");
 511         ctdb_tunnel_id_print(c->tunnel_id, fp);
 512         ctdb_tunnel_flags_print(c->flags, fp);
 513         tdb_data_print(c->data, fp);
 514         fprintf(fp, "\n");
 515 }
 516
 517 /*
 518  * Parse routines
 519  */
 520
 521 static void ctdb_req_call_parse(uint8_t *buf, size_t buflen, FILE *fp,
 522                                 TALLOC_CTX *mem_ctx)
 523 {
 524         struct ctdb_req_call c;
 525         int ret;
 526
 527         ret = ctdb_req_call_pull(buf, buflen, NULL, mem_ctx, &c);
 528         if (ret != 0) {
 529                 fprintf(fp, "Failed to parse CTDB_REQ_CALL\n");
 530                 return;
 531         }
 532
 533         ctdb_req_call_print(&c, fp);
 534 }
 535
 536 static void ctdb_reply_call_parse(uint8_t *buf, size_t buflen, FILE *fp,
 537                                   TALLOC_CTX *mem_ctx)
 538 {
 539         struct ctdb_reply_call c;
 540         int ret;
 541
 542         ret = ctdb_reply_call_pull(buf, buflen, NULL, mem_ctx, &c);
 543         if (ret != 0) {
 544                 fprintf(fp, "Failed to parse CTDB_REPLY_CALL\n");
 545                 return;
 546         }
 547
 548         ctdb_reply_call_print(&c, fp);
 549 }
 550
 551 static void ctdb_req_dmaster_parse(uint8_t *buf, size_t buflen, FILE *fp,
 552                                    TALLOC_CTX *mem_ctx)
 553 {
 554         struct ctdb_req_dmaster c;
 555         int ret;
 556
 557         ret = ctdb_req_dmaster_pull(buf, buflen, NULL, mem_ctx, &c);
 558         if (ret != 0) {
 559                 fprintf(fp, "Failed to parse CTDB_REQ_DMASTER\n");
 560                 return;
 561         }
 562
 563         ctdb_req_dmaster_print(&c, fp);
 564 }
 565
 566 static void ctdb_reply_dmaster_parse(uint8_t *buf, size_t buflen, FILE *fp,
 567                                      TALLOC_CTX *mem_ctx)
 568 {
 569         struct ctdb_reply_dmaster c;
 570         int ret;
 571
 572         ret = ctdb_reply_dmaster_pull(buf, buflen, NULL, mem_ctx, &c);
 573         if (ret != 0) {
 574                 fprintf(fp, "Failed to parse CTDB_REPLY_DMASTER\n");
 575                 return;
 576         }
 577
 578         ctdb_reply_dmaster_print(&c, fp);
 579 }
 580
 581 static void ctdb_reply_error_parse(uint8_t *buf, size_t buflen, FILE *fp,
 582                                    TALLOC_CTX *mem_ctx)
 583 {
 584         struct ctdb_reply_error c;
 585         int ret;
 586
 587         ret = ctdb_reply_error_pull(buf, buflen, NULL, mem_ctx, &c);
 588         if (ret != 0) {
 589                 fprintf(fp, "Failed to parse CTDB_REPLY_ERROR\n");
 590                 return;
 591         }
 592
 593         ctdb_reply_error_print(&c, fp);
 594 }
 595
 596 static void ctdb_req_message_parse(uint8_t *buf, size_t buflen, FILE *fp,
 597                                    TALLOC_CTX *mem_ctx)
 598 {
 599         struct ctdb_req_message_data c;
 600         int ret;
 601
 602         ret = ctdb_req_message_data_pull(buf, buflen, NULL, mem_ctx, &c);
 603         if (ret != 0) {
 604                 fprintf(fp, "Failed to parse CTDB_REQ_MESSAGE\n");
 605                 return;
 606         }
 607
 608         ctdb_req_message_data_print(&c, fp);
 609 }
 610
 611 static void ctdb_req_control_parse(uint8_t *buf, size_t buflen, FILE *fp,
 612                                    TALLOC_CTX *mem_ctx)
 613 {
 614         struct ctdb_req_control c;
 615         int ret;
 616
 617         ret = ctdb_req_control_pull(buf, buflen, NULL, mem_ctx, &c);
 618         if (ret != 0) {
 619                 fprintf(fp, "Failed to parse CTDB_REQ_CONTROL\n");
 620                 return;
 621         }
 622
 623         ctdb_req_control_print(&c, fp);
 624 }
 625
 626 static void ctdb_reply_control_parse(uint8_t *buf, size_t buflen, FILE *fp,
 627                                      TALLOC_CTX *mem_ctx)
 628 {
 629         struct ctdb_reply_control c;
 630         int ret;
 631
 632         ret = ctdb_reply_control_pull(buf, buflen, -1, NULL, mem_ctx, &c);
 633         if (ret != 0) {
 634                 fprintf(fp, "Failed to parse CTDB_REPLY_CONTROL\n");
 635                 return;
 636         }
 637
 638         ctdb_reply_control_print(&c, fp);
 639 }
 640
 641 static void ctdb_req_keepalive_parse(uint8_t *buf, size_t buflen, FILE *fp,
 642                                      TALLOC_CTX *mem_ctx)
 643 {
 644         struct ctdb_req_keepalive c;
 645         int ret;
 646
 647         ret = ctdb_req_keepalive_pull(buf, buflen, NULL, mem_ctx, &c);
 648         if (ret != 0) {
 649                 fprintf(fp, "Failed to parse CTDB_REQ_KEEPALIVE\n");
 650                 return;
 651         }
 652
 653         ctdb_req_keepalive_print(&c, fp);
 654 }
 655
 656 static void ctdb_req_tunnel_parse(uint8_t *buf, size_t buflen, FILE *fp,
 657                                   TALLOC_CTX *mem_ctx)
 658 {
 659         struct ctdb_req_tunnel c;
 660         int ret;
 661
 662         ret = ctdb_req_tunnel_pull(buf, buflen, NULL, mem_ctx, &c);
 663         if (ret != 0) {
 664                 fprintf(fp, "Failed to parse CTDB_REQ_TUNNEL\n");
 665                 return;
 666         }
 667
 668         ctdb_req_tunnel_print(&c, fp);
 669 }
 670
 671 /*
 672  * Packet print
 673  */
 674
 675 void ctdb_packet_print(uint8_t *buf, size_t buflen, FILE *fp)
 676 {
 677         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 678         struct ctdb_req_header h;
 679         size_t np;
 680         int ret;
 681
 682         fprintf(fp, "Buffer len:%zu\n", buflen);
 683
 684         ret = ctdb_req_header_pull(buf, buflen, &h, &np);
 685         if (ret != 0) {
 686                 fprintf(fp, "Failed to parse ctdb packet header\n");
 687                 return;
 688         }
 689
 690         ctdb_req_header_print(&h, fp);
 691
 692         if (h.length > buflen) {
 693                 fprintf(fp, "Packet length mismatch\n");
 694         }
 695
 696         ret = ctdb_req_header_verify(&h, 0);
 697         if (ret != 0) {
 698                 fprintf(fp, "Invalid ctdb packet header\n");
 699                 return;
 700         }
 701
 702         switch (h.operation) {
 703                 case CTDB_REQ_CALL:
 704                         ctdb_req_call_parse(buf, buflen, fp, mem_ctx);
 705                         break;
 706
 707                 case CTDB_REPLY_CALL:
 708                         ctdb_reply_call_parse(buf, buflen, fp, mem_ctx);
 709                         break;
 710
 711                 case CTDB_REQ_DMASTER:
 712                         ctdb_req_dmaster_parse(buf, buflen, fp, mem_ctx);
 713                         break;
 714
 715                 case CTDB_REPLY_DMASTER:
 716                         ctdb_reply_dmaster_parse(buf, buflen, fp, mem_ctx);
 717                         break;
 718
 719                 case CTDB_REPLY_ERROR:
 720                         ctdb_reply_error_parse(buf, buflen, fp, mem_ctx);
 721                         break;
 722
 723                 case CTDB_REQ_MESSAGE:
 724                         ctdb_req_message_parse(buf, buflen, fp, mem_ctx);
 725                         break;
 726
 727                 case CTDB_REQ_CONTROL:
 728                         ctdb_req_control_parse(buf, buflen, fp, mem_ctx);
 729                         break;
 730
 731                 case CTDB_REPLY_CONTROL:
 732                         ctdb_reply_control_parse(buf, buflen, fp, mem_ctx);
 733                         break;
 734
 735                 case CTDB_REQ_KEEPALIVE:
 736                         ctdb_req_keepalive_parse(buf, buflen, fp, mem_ctx);
 737                         break;
 738
 739                 case CTDB_REQ_TUNNEL:
 740                         ctdb_req_tunnel_parse(buf, buflen, fp, mem_ctx);
 741                         break;
 742
 743                 default:
 744                         fprintf(fp, "Invalid ctdb operation\n");
 745                         break;
 746         }
 747
 748         talloc_free(mem_ctx);
 749 }