ctdb/protocol/protocol_message.c

   1 /*
   2    CTDB protocol marshalling
   3
   4    Copyright (C) Amitay Isaacs  2015
   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
  23 #include <talloc.h>
  24 #include <tdb.h>
  25
  26 #include "protocol.h"
  27 #include "protocol_api.h"
  28 #include "protocol_private.h"
  29
  30 struct ctdb_req_message_wire {
  31         struct ctdb_req_header hdr;
  32         uint64_t srvid;
  33         uint32_t datalen;
  34         uint8_t data[1];
  35 };
  36
  37 static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
  38                                     uint64_t srvid)
  39 {
  40         size_t len = 0;
  41
  42         switch (srvid) {
  43         case CTDB_SRVID_BANNING:
  44                 len = ctdb_uint32_len(mdata->pnn);
  45                 break;
  46
  47         case CTDB_SRVID_ELECTION:
  48                 len = ctdb_election_message_len(mdata->election);
  49                 break;
  50
  51         case CTDB_SRVID_RECONFIGURE:
  52                 break;
  53
  54         case CTDB_SRVID_RELEASE_IP:
  55                 len = ctdb_string_len(mdata->ipaddr);
  56                 break;
  57
  58         case CTDB_SRVID_TAKE_IP:
  59                 len = ctdb_string_len(mdata->ipaddr);
  60                 break;
  61
  62         case CTDB_SRVID_SET_NODE_FLAGS:
  63                 len = ctdb_node_flag_change_len(mdata->flag_change);
  64                 break;
  65
  66         case CTDB_SRVID_RECD_UPDATE_IP:
  67                 len = ctdb_public_ip_len(mdata->pubip);
  68                 break;
  69
  70         case CTDB_SRVID_VACUUM_FETCH:
  71                 len = ctdb_rec_buffer_len(mdata->recbuf);
  72                 break;
  73
  74         case CTDB_SRVID_DETACH_DATABASE:
  75                 len = ctdb_uint32_len(mdata->db_id);
  76                 break;
  77
  78         case CTDB_SRVID_MEM_DUMP:
  79                 len = ctdb_srvid_message_len(mdata->msg);
  80                 break;
  81
  82         case CTDB_SRVID_PUSH_NODE_FLAGS:
  83                 len = ctdb_node_flag_change_len(mdata->flag_change);
  84                 break;
  85
  86         case CTDB_SRVID_RELOAD_NODES:
  87                 break;
  88
  89         case CTDB_SRVID_TAKEOVER_RUN:
  90                 len = ctdb_srvid_message_len(mdata->msg);
  91                 break;
  92
  93         case CTDB_SRVID_REBALANCE_NODE:
  94                 len = ctdb_uint32_len(mdata->pnn);
  95                 break;
  96
  97         case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
  98                 len = ctdb_disable_message_len(mdata->disable);
  99                 break;
 100
 101         case CTDB_SRVID_DISABLE_RECOVERIES:
 102                 len = ctdb_disable_message_len(mdata->disable);
 103                 break;
 104
 105         case CTDB_SRVID_DISABLE_IP_CHECK:
 106                 len = ctdb_uint32_len(mdata->timeout);
 107                 break;
 108
 109         default:
 110                 len = ctdb_tdb_data_len(mdata->data);
 111                 break;
 112         }
 113
 114         return len;
 115 }
 116
 117 static void ctdb_message_data_push(union ctdb_message_data *mdata,
 118                                    uint64_t srvid, uint8_t *buf)
 119 {
 120         switch (srvid) {
 121         case CTDB_SRVID_BANNING:
 122                 ctdb_uint32_push(mdata->pnn, buf);
 123                 break;
 124
 125         case CTDB_SRVID_ELECTION:
 126                 ctdb_election_message_push(mdata->election, buf);
 127                 break;
 128
 129         case CTDB_SRVID_RECONFIGURE:
 130                 break;
 131
 132         case CTDB_SRVID_RELEASE_IP:
 133                 ctdb_string_push(mdata->ipaddr, buf);
 134                 break;
 135
 136         case CTDB_SRVID_TAKE_IP:
 137                 ctdb_string_push(mdata->ipaddr, buf);
 138                 break;
 139
 140         case CTDB_SRVID_SET_NODE_FLAGS:
 141                 ctdb_node_flag_change_push(mdata->flag_change, buf);
 142                 break;
 143
 144         case CTDB_SRVID_RECD_UPDATE_IP:
 145                 ctdb_public_ip_push(mdata->pubip, buf);
 146                 break;
 147
 148         case CTDB_SRVID_VACUUM_FETCH:
 149                 ctdb_rec_buffer_push(mdata->recbuf, buf);
 150                 break;
 151
 152         case CTDB_SRVID_DETACH_DATABASE:
 153                 ctdb_uint32_push(mdata->db_id, buf);
 154                 break;
 155
 156         case CTDB_SRVID_MEM_DUMP:
 157                 ctdb_srvid_message_push(mdata->msg, buf);
 158                 break;
 159
 160         case CTDB_SRVID_PUSH_NODE_FLAGS:
 161                 ctdb_node_flag_change_push(mdata->flag_change, buf);
 162                 break;
 163
 164         case CTDB_SRVID_RELOAD_NODES:
 165                 break;
 166
 167         case CTDB_SRVID_TAKEOVER_RUN:
 168                 ctdb_srvid_message_push(mdata->msg, buf);
 169                 break;
 170
 171         case CTDB_SRVID_REBALANCE_NODE:
 172                 ctdb_uint32_push(mdata->pnn, buf);
 173                 break;
 174
 175         case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
 176                 ctdb_disable_message_push(mdata->disable, buf);
 177                 break;
 178
 179         case CTDB_SRVID_DISABLE_RECOVERIES:
 180                 ctdb_disable_message_push(mdata->disable, buf);
 181                 break;
 182
 183         case CTDB_SRVID_DISABLE_IP_CHECK:
 184                 ctdb_uint32_push(mdata->timeout, buf);
 185                 break;
 186
 187         default:
 188                 ctdb_tdb_data_push(mdata->data, buf);
 189                 break;
 190         }
 191 }
 192
 193 static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 194                                   uint64_t srvid, TALLOC_CTX *mem_ctx,
 195                                   union ctdb_message_data *mdata)
 196 {
 197         int ret = 0;
 198
 199         switch (srvid) {
 200         case CTDB_SRVID_BANNING:
 201                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
 202                 break;
 203
 204         case CTDB_SRVID_ELECTION:
 205                 ret = ctdb_election_message_pull(buf, buflen, mem_ctx,
 206                                                  &mdata->election);
 207                 break;
 208
 209         case CTDB_SRVID_RECONFIGURE:
 210                 break;
 211
 212         case CTDB_SRVID_RELEASE_IP:
 213                 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr);
 214                 break;
 215
 216         case CTDB_SRVID_TAKE_IP:
 217                 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr);
 218                 break;
 219
 220         case CTDB_SRVID_SET_NODE_FLAGS:
 221                 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
 222                                                  &mdata->flag_change);
 223                 break;
 224
 225         case CTDB_SRVID_RECD_UPDATE_IP:
 226                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 227                                           &mdata->pubip);
 228                 break;
 229
 230         case CTDB_SRVID_VACUUM_FETCH:
 231                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 232                                            &mdata->recbuf);
 233                 break;
 234
 235         case CTDB_SRVID_DETACH_DATABASE:
 236                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->db_id);
 237                 break;
 238
 239         case CTDB_SRVID_MEM_DUMP:
 240                 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
 241                                               &mdata->msg);
 242                 break;
 243
 244         case CTDB_SRVID_PUSH_NODE_FLAGS:
 245                 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
 246                                                  &mdata->flag_change);
 247                 break;
 248
 249         case CTDB_SRVID_RELOAD_NODES:
 250                 break;
 251
 252         case CTDB_SRVID_TAKEOVER_RUN:
 253                 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
 254                                               &mdata->msg);
 255                 break;
 256
 257         case CTDB_SRVID_REBALANCE_NODE:
 258                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
 259                 break;
 260
 261         case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
 262                 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
 263                                                 &mdata->disable);
 264                 break;
 265
 266         case CTDB_SRVID_DISABLE_RECOVERIES:
 267                 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
 268                                                 &mdata->disable);
 269                 break;
 270
 271         case CTDB_SRVID_DISABLE_IP_CHECK:
 272                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->timeout);
 273                 break;
 274
 275         default:
 276                 ret = ctdb_tdb_data_pull(buf, buflen, mem_ctx, &mdata->data);
 277                 break;
 278         }
 279
 280         return ret;
 281 }
 282
 283 int ctdb_req_message_push(struct ctdb_req_header *h,
 284                           struct ctdb_req_message *message,
 285                           TALLOC_CTX *mem_ctx,
 286                           uint8_t **pkt, size_t *pkt_len)
 287 {
 288         struct ctdb_req_message_wire *wire;
 289         uint8_t *buf;
 290         size_t length, buflen, datalen;
 291         int ret;
 292
 293         datalen = ctdb_message_data_len(&message->data, message->srvid);
 294         length = offsetof(struct ctdb_req_message_wire, data) + datalen;
 295
 296         ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
 297         if (ret != 0) {
 298                 return ret;
 299         }
 300
 301         wire = (struct ctdb_req_message_wire *)buf;
 302
 303         h->length = buflen;
 304         memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));
 305
 306         wire->srvid = message->srvid;
 307         wire->datalen = datalen;
 308         ctdb_message_data_push(&message->data, message->srvid, wire->data);
 309
 310         *pkt = buf;
 311         *pkt_len = buflen;
 312         return 0;
 313 }
 314
 315 int ctdb_req_message_pull(uint8_t *pkt, size_t pkt_len,
 316                           struct ctdb_req_header *h,
 317                           TALLOC_CTX *mem_ctx,
 318                           struct ctdb_req_message *message)
 319 {
 320         struct ctdb_req_message_wire *wire =
 321                 (struct ctdb_req_message_wire *)pkt;
 322         size_t length;
 323         int ret;
 324
 325         length = offsetof(struct ctdb_req_message_wire, data);
 326
 327         if (pkt_len < length) {
 328                 return EMSGSIZE;
 329         }
 330         if (pkt_len < length + wire->datalen) {
 331                 return EMSGSIZE;
 332         }
 333
 334         memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));
 335
 336         message->srvid = wire->srvid;
 337         ret = ctdb_message_data_pull(wire->data, wire->datalen, wire->srvid,
 338                                      mem_ctx, &message->data);
 339         return ret;
 340 }
 341
 342 int ctdb_req_message_data_push(struct ctdb_req_header *h,
 343                                struct ctdb_req_message_data *message,
 344                                TALLOC_CTX *mem_ctx,
 345                                uint8_t **pkt, size_t *pkt_len)
 346 {
 347         struct ctdb_req_message_wire *wire;
 348         uint8_t *buf;
 349         size_t length, buflen;
 350         int ret;
 351
 352         length = offsetof(struct ctdb_req_message_wire, data) +
 353                  message->data.dsize;
 354
 355         ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
 356         if (ret != 0) {
 357                 return ret;
 358         }
 359
 360         wire = (struct ctdb_req_message_wire *)buf;
 361
 362         h->length = buflen;
 363         memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));
 364
 365         wire->srvid = message->srvid;
 366         wire->datalen = message->data.dsize;
 367         if (message->data.dsize > 0) {
 368                 memcpy(wire->data, message->data.dptr, message->data.dsize);
 369         }
 370
 371         *pkt = buf;
 372         *pkt_len = buflen;
 373         return 0;
 374 }
 375
 376 int ctdb_req_message_data_pull(uint8_t *pkt, size_t pkt_len,
 377                                struct ctdb_req_header *h,
 378                                TALLOC_CTX *mem_ctx,
 379                                struct ctdb_req_message_data *message)
 380 {
 381         struct ctdb_req_message_wire *wire =
 382                 (struct ctdb_req_message_wire *)pkt;
 383         size_t length;
 384
 385         length = offsetof(struct ctdb_req_message_wire, data);
 386
 387         if (pkt_len < length) {
 388                 return EMSGSIZE;
 389         }
 390         if (pkt_len < length + wire->datalen) {
 391                 return EMSGSIZE;
 392         }
 393
 394         memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));
 395
 396         message->srvid = wire->srvid;
 397         message->data.dsize = wire->datalen;
 398         if (wire->datalen > 0) {
 399                 message->data.dptr = talloc_memdup(mem_ctx, wire->data,
 400                                                    wire->datalen);
 401                 if (message->data.dptr == NULL) {
 402                         return ENOMEM;
 403                 }
 404         }
 405
 406         return 0;
 407 }