ctdb/protocol/protocol_event.c

   1 /*
   2    CTDB eventd 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
  23 #include <talloc.h>
  24
  25 #include "protocol.h"
  26 #include "protocol_private.h"
  27 #include "protocol_api.h"
  28
  29 static size_t ctdb_event_len(enum ctdb_event in)
  30 {
  31         return ctdb_uint32_len((uint32_t)in);
  32 }
  33
  34 static void ctdb_event_push(enum ctdb_event in, uint8_t *buf)
  35 {
  36         ctdb_uint32_push((uint32_t)in, buf);
  37 }
  38
  39 static int ctdb_event_pull(uint8_t *buf, size_t buflen,
  40                            TALLOC_CTX *mem_ctx, enum ctdb_event *out)
  41 {
  42         uint32_t uint32_value;
  43         enum ctdb_event value;
  44         int ret;
  45
  46         ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
  47         if (ret != 0) {
  48                 return ret;
  49         }
  50
  51         switch (uint32_value) {
  52         case 0:
  53                 value = CTDB_EVENT_INIT;
  54                 break;
  55
  56         case 1:
  57                 value = CTDB_EVENT_SETUP;
  58                 break;
  59
  60         case 2:
  61                 value = CTDB_EVENT_STARTUP;
  62                 break;
  63
  64         case 3:
  65                 value = CTDB_EVENT_START_RECOVERY;
  66                 break;
  67
  68         case 4:
  69                 value = CTDB_EVENT_RECOVERED;
  70                 break;
  71
  72         case 5:
  73                 value = CTDB_EVENT_TAKE_IP;
  74                 break;
  75
  76         case 6:
  77                 value = CTDB_EVENT_RELEASE_IP;
  78                 break;
  79
  80         case 7:
  81                 value = CTDB_EVENT_STOPPED;
  82                 break;
  83
  84         case 8:
  85                 value = CTDB_EVENT_MONITOR;
  86                 break;
  87
  88         case 9:
  89                 value = CTDB_EVENT_STATUS;
  90                 break;
  91
  92         case 10:
  93                 value = CTDB_EVENT_SHUTDOWN;
  94                 break;
  95
  96         case 11:
  97                 value = CTDB_EVENT_RELOAD;
  98                 break;
  99
 100         case 12:
 101                 value = CTDB_EVENT_UPDATE_IP;
 102                 break;
 103
 104         case 13:
 105                 value = CTDB_EVENT_IPREALLOCATED;
 106                 break;
 107
 108         default:
 109                 return EINVAL;
 110         }
 111
 112         *out = value;
 113         return 0;
 114 }
 115
 116 static size_t ctdb_event_command_len(enum ctdb_event_command in)
 117 {
 118         return ctdb_uint32_len((uint32_t)in);
 119 }
 120
 121 static void ctdb_event_command_push(enum ctdb_event_command in, uint8_t *buf)
 122 {
 123         ctdb_uint32_push((uint32_t)in, buf);
 124 }
 125
 126 static int ctdb_event_command_pull(uint8_t *buf, size_t buflen,
 127                                    TALLOC_CTX *mem_ctx,
 128                                    enum ctdb_event_command *out)
 129 {
 130         uint32_t uint32_value;
 131         enum ctdb_event_command value;
 132         int ret;
 133
 134         ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
 135         if (ret != 0) {
 136                 return ret;
 137         }
 138
 139         switch (uint32_value) {
 140         case 1:
 141                 value = CTDB_EVENT_COMMAND_RUN;
 142                 break;
 143
 144         case 2:
 145                 value = CTDB_EVENT_COMMAND_STATUS;
 146                 break;
 147
 148         case 3:
 149                 value = CTDB_EVENT_COMMAND_SCRIPT_LIST;
 150                 break;
 151
 152         case 4:
 153                 value = CTDB_EVENT_COMMAND_SCRIPT_ENABLE;
 154                 break;
 155
 156         case 5:
 157                 value = CTDB_EVENT_COMMAND_SCRIPT_DISABLE;
 158                 break;
 159
 160         default:
 161                 return EINVAL;
 162         }
 163
 164         *out = value;
 165         return 0;
 166 }
 167
 168 static size_t ctdb_event_status_state_len(enum ctdb_event_status_state in)
 169 {
 170         return ctdb_uint32_len((uint32_t)in);
 171 }
 172
 173 static void ctdb_event_status_state_push(enum ctdb_event_status_state in,
 174                                          uint8_t *buf)
 175 {
 176         ctdb_uint32_push((uint32_t)in, buf);
 177 }
 178
 179 static int ctdb_event_status_state_pull(uint8_t *buf, size_t buflen,
 180                                         TALLOC_CTX *mem_ctx,
 181                                         enum ctdb_event_status_state *out)
 182 {
 183         uint32_t uint32_value;
 184         enum ctdb_event_status_state value;
 185         int ret;
 186
 187         ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
 188         if (ret != 0) {
 189                 return ret;
 190         }
 191
 192         switch (uint32_value) {
 193         case 1:
 194                 value = CTDB_EVENT_LAST_RUN;
 195                 break;
 196
 197         case 2:
 198                 value = CTDB_EVENT_LAST_PASS;
 199                 break;
 200
 201         case 3:
 202                 value = CTDB_EVENT_LAST_FAIL;
 203                 break;
 204
 205         default:
 206                 return EINVAL;
 207         }
 208
 209         *out = value;
 210         return 0;
 211 }
 212
 213 static size_t ctdb_event_request_run_len(struct ctdb_event_request_run *in)
 214 {
 215         return ctdb_event_len(in->event) +
 216                ctdb_uint32_len(in->timeout) +
 217                ctdb_stringn_len(in->arg_str);
 218 }
 219
 220 static void ctdb_event_request_run_push(struct ctdb_event_request_run *in,
 221                                         uint8_t *buf)
 222 {
 223         size_t offset = 0;
 224
 225         ctdb_event_push(in->event, buf);
 226         offset += ctdb_event_len(in->event);
 227
 228         ctdb_uint32_push(in->timeout, buf+offset);
 229         offset += ctdb_uint32_len(in->timeout);
 230
 231         ctdb_stringn_push(in->arg_str, buf+offset);
 232 }
 233
 234 static int ctdb_event_request_run_pull(uint8_t *buf, size_t buflen,
 235                                        TALLOC_CTX *mem_ctx,
 236                                        struct ctdb_event_request_run **out)
 237 {
 238         struct ctdb_event_request_run *rdata;
 239         size_t offset = 0;
 240         int ret;
 241
 242         rdata = talloc(mem_ctx, struct ctdb_event_request_run);
 243         if (rdata == NULL) {
 244                 return ENOMEM;
 245         }
 246
 247         ret = ctdb_event_pull(buf, buflen, rdata, &rdata->event);
 248         if (ret != 0) {
 249                 goto fail;
 250         }
 251         offset += ctdb_event_len(rdata->event);
 252
 253         ret = ctdb_uint32_pull(buf+offset, buflen-offset,
 254                                rdata, &rdata->timeout);
 255         if (ret != 0) {
 256                 goto fail;
 257         }
 258         offset += ctdb_uint32_len(rdata->timeout);
 259
 260         ret = ctdb_stringn_pull(buf+offset, buflen-offset,
 261                                 rdata, &rdata->arg_str);
 262         if (ret != 0) {
 263                 goto fail;
 264         }
 265
 266         *out = rdata;
 267         return 0;
 268
 269 fail:
 270         talloc_free(rdata);
 271         return ret;
 272 }
 273
 274 static size_t ctdb_event_request_status_len(
 275                                 struct ctdb_event_request_status *in)
 276 {
 277         return ctdb_event_len(in->event) +
 278                ctdb_event_status_state_len(in->state);
 279 }
 280
 281 static void ctdb_event_request_status_push(
 282                                 struct ctdb_event_request_status *in,
 283                                 uint8_t *buf)
 284 {
 285         size_t offset = 0;
 286
 287         ctdb_event_push(in->event, buf);
 288         offset += ctdb_event_len(in->event);
 289
 290         ctdb_event_status_state_push(in->state, buf+offset);
 291 }
 292
 293 static int ctdb_event_request_status_pull(
 294                                 uint8_t *buf, size_t buflen,
 295                                 TALLOC_CTX *mem_ctx,
 296                                 struct ctdb_event_request_status **out)
 297 {
 298         struct ctdb_event_request_status *rdata;
 299         size_t offset = 0;
 300         int ret;
 301
 302         rdata = talloc(mem_ctx, struct ctdb_event_request_status);
 303         if (rdata == NULL) {
 304                 return ENOMEM;
 305         }
 306
 307         ret = ctdb_event_pull(buf, buflen, rdata, &rdata->event);
 308         if (ret != 0) {
 309                 talloc_free(rdata);
 310                 return ret;
 311         }
 312         offset += ctdb_event_len(rdata->event);
 313
 314         ret = ctdb_event_status_state_pull(buf+offset, buflen-offset,
 315                                            rdata, &rdata->state);
 316         if (ret != 0) {
 317                 talloc_free(rdata);
 318                 return ret;
 319         }
 320
 321         *out = rdata;
 322         return 0;
 323 }
 324
 325 static size_t ctdb_event_request_script_enable_len(
 326                                 struct ctdb_event_request_script_enable *in)
 327 {
 328         return ctdb_stringn_len(in->script_name);
 329 }
 330
 331 static void ctdb_event_request_script_enable_push(
 332                                 struct ctdb_event_request_script_enable *in,
 333                                 uint8_t *buf)
 334 {
 335         ctdb_stringn_push(in->script_name, buf);
 336 }
 337
 338 static int ctdb_event_request_script_enable_pull(
 339                                 uint8_t *buf, size_t buflen,
 340                                 TALLOC_CTX *mem_ctx,
 341                                 struct ctdb_event_request_script_enable **out)
 342 {
 343         struct ctdb_event_request_script_enable *rdata;
 344         int ret;
 345
 346         rdata = talloc(mem_ctx, struct ctdb_event_request_script_enable);
 347         if (rdata == NULL) {
 348                 return ENOMEM;
 349         }
 350
 351         ret = ctdb_stringn_pull(buf, buflen, rdata, &rdata->script_name);
 352         if (ret != 0) {
 353                 talloc_free(rdata);
 354                 return ret;
 355         }
 356
 357         *out = rdata;
 358         return 0;
 359 }
 360
 361 static size_t ctdb_event_request_script_disable_len(
 362                                 struct ctdb_event_request_script_disable *in)
 363 {
 364         return ctdb_stringn_len(in->script_name);
 365 }
 366
 367 static void ctdb_event_request_script_disable_push(
 368                                 struct ctdb_event_request_script_disable *in,
 369                                 uint8_t *buf)
 370 {
 371         ctdb_stringn_push(in->script_name, buf);
 372 }
 373
 374 static int ctdb_event_request_script_disable_pull(
 375                                 uint8_t *buf, size_t buflen,
 376                                 TALLOC_CTX *mem_ctx,
 377                                 struct ctdb_event_request_script_disable **out)
 378 {
 379         struct ctdb_event_request_script_disable *rdata;
 380         int ret;
 381
 382         rdata = talloc(mem_ctx, struct ctdb_event_request_script_disable);
 383         if (rdata == NULL) {
 384                 return ENOMEM;
 385         }
 386
 387         ret = ctdb_stringn_pull(buf, buflen, rdata, &rdata->script_name);
 388         if (ret != 0) {
 389                 talloc_free(rdata);
 390                 return ret;
 391         }
 392
 393         *out = rdata;
 394         return 0;
 395 }
 396
 397 static size_t ctdb_event_request_data_len(struct ctdb_event_request_data *in)
 398 {
 399         size_t len = 0;
 400
 401         len += ctdb_event_command_len(in->command);
 402
 403         switch(in->command) {
 404         case CTDB_EVENT_COMMAND_RUN:
 405                 len += ctdb_event_request_run_len(in->data.run);
 406                 break;
 407
 408         case CTDB_EVENT_COMMAND_STATUS:
 409                 len += ctdb_event_request_status_len(in->data.status);
 410                 break;
 411
 412         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 413                 break;
 414
 415         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 416                 len += ctdb_event_request_script_enable_len(
 417                                                 in->data.script_enable);
 418                 break;
 419
 420         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 421                 len += ctdb_event_request_script_disable_len(
 422                                                 in->data.script_disable);
 423                 break;
 424         }
 425
 426         return len;
 427 }
 428
 429 static void ctdb_event_request_data_push(struct ctdb_event_request_data *in,
 430                                          uint8_t *buf)
 431 {
 432         size_t offset = 0;
 433
 434         ctdb_event_command_push(in->command, buf);
 435         offset += ctdb_event_command_len(in->command);
 436
 437         switch (in->command) {
 438         case CTDB_EVENT_COMMAND_RUN:
 439                 ctdb_event_request_run_push(in->data.run, buf+offset);
 440                 break;
 441
 442         case CTDB_EVENT_COMMAND_STATUS:
 443                 ctdb_event_request_status_push(in->data.status, buf+offset);
 444                 break;
 445
 446         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 447                 break;
 448
 449         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 450                 ctdb_event_request_script_enable_push(
 451                                                 in->data.script_enable,
 452                                                 buf+offset);
 453                 break;
 454
 455         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 456                 ctdb_event_request_script_disable_push(
 457                                                 in->data.script_disable,
 458                                                 buf+offset);
 459                 break;
 460         }
 461 }
 462
 463 static int ctdb_event_request_data_pull(uint8_t *buf, size_t buflen,
 464                                         TALLOC_CTX *mem_ctx,
 465                                         struct ctdb_event_request_data *out)
 466 {
 467         size_t offset = 0;
 468         int ret;
 469
 470         ret = ctdb_event_command_pull(buf, buflen, mem_ctx, &out->command);
 471         if (ret != 0) {
 472                 return ret;
 473         }
 474         offset += ctdb_event_command_len(out->command);
 475
 476         switch (out->command) {
 477         case CTDB_EVENT_COMMAND_RUN:
 478                 ret = ctdb_event_request_run_pull(buf+offset, buflen-offset,
 479                                                   mem_ctx, &out->data.run);
 480                 break;
 481
 482         case CTDB_EVENT_COMMAND_STATUS:
 483                 ret = ctdb_event_request_status_pull(
 484                                                 buf+offset, buflen-offset,
 485                                                 mem_ctx, &out->data.status);
 486                 break;
 487
 488         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 489                 ret = 0;
 490                 break;
 491
 492         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 493                 ret = ctdb_event_request_script_enable_pull(
 494                                                 buf+offset, buflen-offset,
 495                                                 mem_ctx,
 496                                                 &out->data.script_enable);
 497                 break;
 498
 499         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 500                 ret = ctdb_event_request_script_disable_pull(
 501                                                 buf+offset, buflen-offset,
 502                                                 mem_ctx,
 503                                                 &out->data.script_disable);
 504                 break;
 505         }
 506
 507         if (ret != 0) {
 508                 return ret;
 509         }
 510
 511         return 0;
 512 }
 513
 514 static size_t ctdb_event_reply_status_len(struct ctdb_event_reply_status *in)
 515 {
 516         return ctdb_int32_len(in->status) +
 517                ctdb_script_list_len(in->script_list);
 518 }
 519
 520 static void ctdb_event_reply_status_push(struct ctdb_event_reply_status *in,
 521                                          uint8_t *buf)
 522 {
 523         size_t offset = 0;
 524
 525         ctdb_int32_push(in->status, buf);
 526         offset += ctdb_int32_len(in->status);
 527
 528         ctdb_script_list_push(in->script_list, buf+offset);
 529 }
 530
 531 static int ctdb_event_reply_status_pull(uint8_t *buf, size_t buflen,
 532                                         TALLOC_CTX *mem_ctx,
 533                                         struct ctdb_event_reply_status **out)
 534 {
 535         struct ctdb_event_reply_status *rdata;
 536         size_t offset = 0;
 537         int ret;
 538
 539         rdata = talloc(mem_ctx, struct ctdb_event_reply_status);
 540         if (rdata == NULL) {
 541                 return ENOMEM;
 542         }
 543
 544         ret = ctdb_int32_pull(buf, buflen, rdata, &rdata->status);
 545         if (ret != 0) {
 546                 talloc_free(rdata);
 547                 return ret;
 548         }
 549         offset += ctdb_int32_len(rdata->status);
 550
 551         ret = ctdb_script_list_pull(buf+offset, buflen-offset,
 552                                     rdata, &rdata->script_list);
 553         if (ret != 0) {
 554                 talloc_free(rdata);
 555                 return ret;
 556         }
 557
 558         *out = rdata;
 559         return 0;
 560 }
 561
 562 static size_t ctdb_event_reply_script_list_len(
 563                                 struct ctdb_event_reply_script_list *in)
 564 {
 565         return ctdb_script_list_len(in->script_list);
 566 }
 567
 568 static void ctdb_event_reply_script_list_push(
 569                                 struct ctdb_event_reply_script_list *in,
 570                                 uint8_t *buf)
 571 {
 572         ctdb_script_list_push(in->script_list, buf);
 573 }
 574
 575 static int ctdb_event_reply_script_list_pull(
 576                                 uint8_t *buf, size_t buflen,
 577                                 TALLOC_CTX *mem_ctx,
 578                                 struct ctdb_event_reply_script_list **out)
 579 {
 580         struct ctdb_event_reply_script_list *rdata;
 581         int ret;
 582
 583         rdata = talloc(mem_ctx, struct ctdb_event_reply_script_list);
 584         if (rdata == NULL) {
 585                 return ENOMEM;
 586         }
 587
 588         ret = ctdb_script_list_pull(buf, buflen, rdata, &rdata->script_list);
 589         if (ret != 0) {
 590                 talloc_free(rdata);
 591                 return ret;
 592         }
 593
 594         *out = rdata;
 595         return 0;
 596 }
 597
 598 static size_t ctdb_event_reply_data_len(struct ctdb_event_reply_data *in)
 599 {
 600         size_t len = 0;
 601
 602         len += ctdb_event_command_len(in->command);
 603         len += ctdb_int32_len(in->result);
 604
 605         switch (in->command) {
 606         case CTDB_EVENT_COMMAND_RUN:
 607                 break;
 608
 609         case CTDB_EVENT_COMMAND_STATUS:
 610                 len += ctdb_event_reply_status_len(in->data.status);
 611                 break;
 612
 613         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 614                 len += ctdb_event_reply_script_list_len(in->data.script_list);
 615                 break;
 616
 617         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 618                 break;
 619
 620         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 621                 break;
 622         }
 623
 624         return len;
 625 }
 626
 627 static void ctdb_event_reply_data_push(struct ctdb_event_reply_data *in,
 628                                        uint8_t *buf)
 629 {
 630         size_t offset = 0;
 631
 632         ctdb_event_command_push(in->command, buf);
 633         offset += ctdb_event_command_len(in->command);
 634
 635         ctdb_int32_push(in->result, buf+offset);
 636         offset += ctdb_int32_len(in->result);
 637
 638         switch (in->command) {
 639         case CTDB_EVENT_COMMAND_RUN:
 640                 break;
 641
 642         case CTDB_EVENT_COMMAND_STATUS:
 643                 ctdb_event_reply_status_push(in->data.status, buf+offset);
 644                 break;
 645
 646         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 647                 ctdb_event_reply_script_list_push(in->data.script_list,
 648                                                   buf+offset);
 649                 break;
 650
 651         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 652                 break;
 653
 654         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 655                 break;
 656         }
 657 }
 658
 659 static int ctdb_event_reply_data_pull(uint8_t *buf, size_t buflen,
 660                                       TALLOC_CTX *mem_ctx,
 661                                       struct ctdb_event_reply_data *out)
 662 {
 663         size_t offset = 0;
 664         int ret;
 665
 666         ret = ctdb_event_command_pull(buf, buflen, mem_ctx, &out->command);
 667         if (ret != 0) {
 668                 return ret;
 669         }
 670         offset += ctdb_event_command_len(out->command);
 671
 672         ret = ctdb_int32_pull(buf+offset, buflen-offset,
 673                               mem_ctx, &out->result);
 674         if (ret != 0) {
 675                 return ret;
 676         }
 677         offset += ctdb_int32_len(out->result);
 678
 679         switch (out->command) {
 680         case CTDB_EVENT_COMMAND_RUN:
 681                 break;
 682
 683         case CTDB_EVENT_COMMAND_STATUS:
 684                 ret = ctdb_event_reply_status_pull(
 685                                         buf+offset, buflen-offset,
 686                                         mem_ctx, &out->data.status);
 687                 break;
 688
 689         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 690                 ret = ctdb_event_reply_script_list_pull(
 691                                         buf+offset, buflen-offset,
 692                                         mem_ctx, &out->data.script_list);
 693                 break;
 694
 695         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 696                 break;
 697
 698         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 699                 break;
 700         }
 701
 702         if (ret != 0) {
 703                 return ret;
 704         }
 705
 706         return 0;
 707 }
 708
 709 static size_t ctdb_event_header_len(struct ctdb_event_header *in)
 710 {
 711         return ctdb_uint32_len(in->length) + ctdb_uint32_len(in->reqid);
 712 }
 713
 714 static void ctdb_event_header_push(struct ctdb_event_header *in, uint8_t *buf)
 715 {
 716         size_t offset = 0;
 717
 718         ctdb_uint32_push(in->length, buf);
 719         offset += ctdb_uint32_len(in->length);
 720
 721         ctdb_uint32_push(in->reqid, buf+offset);
 722 }
 723
 724 static int ctdb_event_header_pull(uint8_t *buf, size_t buflen,
 725                                   TALLOC_CTX *mem_ctx,
 726                                   struct ctdb_event_header *out)
 727 {
 728         size_t offset = 0;
 729         int ret;
 730
 731         ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &out->length);
 732         if (ret != 0) {
 733                 return ret;
 734         }
 735         offset += ctdb_uint32_len(out->length);
 736
 737         ret = ctdb_uint32_pull(buf+offset, buflen-offset,
 738                                mem_ctx, &out->reqid);
 739         if (ret != 0) {
 740                 return ret;
 741         }
 742
 743         return 0;
 744 }
 745
 746 void ctdb_event_header_fill(struct ctdb_event_header *h, uint32_t reqid)
 747 {
 748         h->length = ctdb_event_header_len(h);
 749         h->reqid = reqid;
 750 }
 751
 752 size_t ctdb_event_request_len(struct ctdb_event_request *in)
 753 {
 754         return ctdb_event_header_len(&in->header) +
 755                ctdb_event_request_data_len(&in->rdata);
 756 }
 757
 758 int ctdb_event_request_push(struct ctdb_event_request *in,
 759                             uint8_t *buf, size_t *buflen)
 760 {
 761         size_t len, offset = 0;
 762
 763         len = ctdb_event_request_len(in);
 764         if (*buflen < len) {
 765                 *buflen = len;
 766                 return EMSGSIZE;
 767         }
 768
 769         in->header.length = *buflen;
 770
 771         ctdb_event_header_push(&in->header, buf);
 772         offset += ctdb_event_header_len(&in->header);
 773
 774         ctdb_event_request_data_push(&in->rdata, buf+offset);
 775
 776         return 0;
 777 }
 778
 779 int ctdb_event_request_pull(uint8_t *buf, size_t buflen,
 780                             TALLOC_CTX *mem_ctx,
 781                             struct ctdb_event_request *out)
 782 {
 783         size_t offset = 0;
 784         int ret;
 785
 786         ret = ctdb_event_header_pull(buf, buflen, mem_ctx, &out->header);
 787         if (ret != 0) {
 788                 return ret;
 789         }
 790         offset += ctdb_event_header_len(&out->header);
 791
 792         ret = ctdb_event_request_data_pull(buf+offset, buflen-offset,
 793                                            mem_ctx, &out->rdata);
 794         if (ret != 0) {
 795                 return ret;
 796         }
 797
 798         return 0;
 799 }
 800
 801 size_t ctdb_event_reply_len(struct ctdb_event_reply *in)
 802 {
 803         return ctdb_event_header_len(&in->header) +
 804                ctdb_event_reply_data_len(&in->rdata);
 805 }
 806
 807 int ctdb_event_reply_push(struct ctdb_event_reply *in,
 808                           uint8_t *buf, size_t *buflen)
 809 {
 810         size_t len, offset = 0;
 811
 812         len = ctdb_event_reply_len(in);
 813         if (*buflen < len) {
 814                 *buflen = len;
 815                 return EMSGSIZE;
 816         }
 817
 818         in->header.length = *buflen;
 819
 820         ctdb_event_header_push(&in->header, buf);
 821         offset += ctdb_event_header_len(&in->header);
 822
 823         ctdb_event_reply_data_push(&in->rdata, buf+offset);
 824
 825         return 0;
 826 }
 827
 828 int ctdb_event_reply_pull(uint8_t *buf, size_t buflen,
 829                           TALLOC_CTX *mem_ctx,
 830                           struct ctdb_event_reply *out)
 831 {
 832         size_t offset = 0;
 833         int ret;
 834
 835         ret = ctdb_event_header_pull(buf, buflen, mem_ctx, &out->header);
 836         if (ret != 0) {
 837                 return ret;
 838         }
 839         offset += ctdb_event_header_len(&out->header);
 840
 841         ret = ctdb_event_reply_data_pull(buf+offset, buflen-offset,
 842                                          mem_ctx, &out->rdata);
 843         if (ret != 0) {
 844                 return ret;
 845         }
 846
 847         return 0;
 848 }