ctdb/event/event_protocol.c

   1 /*
   2    CTDB event daemon protocol
   3
   4    Copyright (C) Amitay Isaacs  2018
   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
  22 #include <talloc.h>
  23
  24 #include "protocol/protocol_basic.h"
  25
  26 #include "event_protocol.h"
  27 #include "event_protocol_api.h"
  28
  29 static size_t ctdb_event_script_action_len(enum ctdb_event_script_action in)
  30 {
  31         uint32_t u32 = in;
  32
  33         return ctdb_uint32_len(&u32);
  34 }
  35
  36 static void ctdb_event_script_action_push(enum ctdb_event_script_action in,
  37                                           uint8_t *buf,
  38                                           size_t *npush)
  39 {
  40         uint32_t u32 = in;
  41
  42         ctdb_uint32_push(&u32, buf, npush);
  43 }
  44
  45 static int ctdb_event_script_action_pull(uint8_t *buf,
  46                                          size_t buflen,
  47                                          enum ctdb_event_script_action *out,
  48                                          size_t *npull)
  49 {
  50         enum ctdb_event_script_action value;
  51         uint32_t u32;
  52         size_t np;
  53         int ret;
  54
  55         ret = ctdb_uint32_pull(buf, buflen, &u32, &np);
  56         if (ret != 0) {
  57                 return ret;
  58         }
  59
  60         switch (u32) {
  61         case 0:
  62                 value = CTDB_EVENT_SCRIPT_DISABLE;
  63                 break;
  64
  65         case 1:
  66                 value = CTDB_EVENT_SCRIPT_ENABLE;
  67                 break;
  68
  69         default:
  70                 return EINVAL;
  71         }
  72
  73         *out = value;
  74         *npull = np;
  75
  76         return 0;
  77 }
  78
  79 static size_t ctdb_event_command_len(enum ctdb_event_command in)
  80 {
  81         uint32_t u32 = in;
  82
  83         return ctdb_uint32_len(&u32);
  84 }
  85
  86 static void ctdb_event_command_push(enum ctdb_event_command in,
  87                                     uint8_t *buf,
  88                                     size_t *npush)
  89 {
  90         uint32_t u32 = in;
  91
  92         ctdb_uint32_push(&u32, buf, npush);
  93 }
  94
  95 static int ctdb_event_command_pull(uint8_t *buf,
  96                                    size_t buflen,
  97                                    enum ctdb_event_command *out,
  98                                    size_t *npull)
  99 {
 100         enum ctdb_event_command value;
 101         uint32_t u32;
 102         size_t np;
 103         int ret;
 104
 105         ret = ctdb_uint32_pull(buf, buflen, &u32, &np);
 106         if (ret != 0) {
 107                 return ret;
 108         }
 109
 110         switch (u32) {
 111         case 1:
 112                 value = CTDB_EVENT_CMD_RUN;
 113                 break;
 114
 115         case 2:
 116                 value = CTDB_EVENT_CMD_STATUS;
 117                 break;
 118
 119         case 3:
 120                 value = CTDB_EVENT_CMD_SCRIPT;
 121                 break;
 122
 123         default:
 124                 return EINVAL;
 125         }
 126
 127         *out = value;
 128         *npull = np;
 129
 130         return 0;
 131 }
 132
 133 static size_t ctdb_event_script_len(struct ctdb_event_script *in)
 134 {
 135         return ctdb_stringn_len(&in->name) +
 136                 ctdb_timeval_len(&in->begin) +
 137                 ctdb_timeval_len(&in->end) +
 138                 ctdb_int32_len(&in->result) +
 139                 ctdb_stringn_len(&in->output);
 140 }
 141
 142 static void ctdb_event_script_push(struct ctdb_event_script *in,
 143                                    uint8_t *buf,
 144                                    size_t *npush)
 145 {
 146         size_t offset = 0, np;
 147
 148         ctdb_stringn_push(&in->name, buf+offset, &np);
 149         offset += np;
 150
 151         ctdb_timeval_push(&in->begin, buf+offset, &np);
 152         offset += np;
 153
 154         ctdb_timeval_push(&in->end, buf+offset, &np);
 155         offset += np;
 156
 157         ctdb_int32_push(&in->result, buf+offset, &np);
 158         offset += np;
 159
 160         ctdb_stringn_push(&in->output, buf+offset, &np);
 161         offset += np;
 162
 163         *npush = offset;
 164 }
 165
 166 static int ctdb_event_script_pull_elems(uint8_t *buf,
 167                                         size_t buflen,
 168                                         TALLOC_CTX *mem_ctx,
 169                                         struct ctdb_event_script *value,
 170                                         size_t *npull)
 171 {
 172         size_t offset = 0, np;
 173         int ret;
 174
 175         ret = ctdb_stringn_pull(buf+offset,
 176                                 buflen-offset,
 177                                 mem_ctx,
 178                                 &value->name,
 179                                 &np);
 180         if (ret != 0) {
 181                 return ret;
 182         }
 183         offset += np;
 184
 185         ret = ctdb_timeval_pull(buf+offset,
 186                                 buflen-offset,
 187                                 &value->begin,
 188                                 &np);
 189         if (ret != 0) {
 190                 return ret;
 191         }
 192         offset += np;
 193
 194         ret = ctdb_timeval_pull(buf+offset,
 195                                 buflen-offset,
 196                                 &value->end,
 197                                 &np);
 198         if (ret != 0) {
 199                 return ret;
 200         }
 201         offset += np;
 202
 203         ret = ctdb_int32_pull(buf+offset,
 204                               buflen-offset,
 205                               &value->result,
 206                               &np);
 207         if (ret != 0) {
 208                 return ret;
 209         }
 210         offset += np;
 211
 212         ret = ctdb_stringn_pull(buf+offset,
 213                                 buflen-offset,
 214                                 mem_ctx,
 215                                 &value->output,
 216                                 &np);
 217         if (ret != 0) {
 218                 return ret;
 219         }
 220         offset += np;
 221
 222         *npull = offset;
 223
 224         return 0;
 225 }
 226
 227 #ifdef EVENT_PROTOCOL_TEST
 228 static int ctdb_event_script_pull(uint8_t *buf,
 229                                   size_t buflen,
 230                                   TALLOC_CTX *mem_ctx,
 231                                   struct ctdb_event_script **out,
 232                                   size_t *npull)
 233 {
 234         struct ctdb_event_script *value;
 235         int ret;
 236
 237         value = talloc(mem_ctx, struct ctdb_event_script);
 238         if (value == NULL) {
 239                 return ENOMEM;
 240         }
 241
 242         ret = ctdb_event_script_pull_elems(buf, buflen, value, value, npull);
 243         if (ret != 0) {
 244                 talloc_free(value);
 245                 return ret;
 246         }
 247
 248         *out = value;
 249
 250         return 0;
 251 }
 252 #endif
 253
 254 static size_t ctdb_event_script_list_len(struct ctdb_event_script_list *in)
 255 {
 256         size_t len;
 257         int i;
 258
 259         len = ctdb_int32_len(&in->num_scripts);
 260
 261         for (i=0; i<in->num_scripts; i++) {
 262                 len += ctdb_event_script_len(&in->script[i]);
 263         }
 264
 265         return len;
 266 }
 267
 268 static void ctdb_event_script_list_push(struct ctdb_event_script_list *in,
 269                                         uint8_t *buf,
 270                                         size_t *npush)
 271 {
 272         size_t offset = 0, np;
 273         int i;
 274
 275         ctdb_int32_push(&in->num_scripts, buf+offset, &np);
 276         offset += np;
 277
 278         for (i=0; i<in->num_scripts; i++) {
 279                 ctdb_event_script_push(&in->script[i], buf+offset, &np);
 280                 offset += np;
 281         }
 282
 283         *npush = offset;
 284 }
 285
 286 static int ctdb_event_script_list_pull(uint8_t *buf,
 287                                        size_t buflen,
 288                                        TALLOC_CTX *mem_ctx,
 289                                        struct ctdb_event_script_list **out,
 290                                        size_t *npull)
 291 {
 292         struct ctdb_event_script_list *value = NULL;
 293         size_t offset = 0, np;
 294         int num_scripts;
 295         int ret, i;
 296
 297         ret = ctdb_int32_pull(buf+offset, buflen-offset, &num_scripts, &np);
 298         if (ret != 0) {
 299                 return ret;
 300         }
 301         offset += np;
 302
 303         if (num_scripts < 0) {
 304                 return EINVAL;
 305         }
 306
 307         value = talloc_zero(mem_ctx, struct ctdb_event_script_list);
 308         if (value == NULL) {
 309                 return ENOMEM;
 310         }
 311
 312         value->num_scripts = num_scripts;
 313         if (num_scripts == 0) {
 314                 goto done;
 315         }
 316
 317         value->script = talloc_array(value, struct ctdb_event_script,
 318                                      num_scripts);
 319         if (value->script == NULL) {
 320                 goto fail;
 321         }
 322
 323         for (i=0; i<num_scripts; i++) {
 324                 ret = ctdb_event_script_pull_elems(buf+offset,
 325                                                    buflen-offset,
 326                                                    value,
 327                                                    &value->script[i],
 328                                                    &np);
 329                 if (ret != 0) {
 330                         goto fail;
 331                 }
 332                 offset += np;
 333         }
 334
 335 done:
 336         *out = value;
 337         *npull = offset;
 338
 339         return 0;
 340
 341 fail:
 342         talloc_free(value);
 343         return ret;
 344 }
 345
 346 static size_t ctdb_event_request_run_len(struct ctdb_event_request_run *in)
 347 {
 348         return ctdb_stringn_len(&in->component) +
 349                 ctdb_stringn_len(&in->event) +
 350                 ctdb_stringn_len(&in->args) +
 351                 ctdb_uint32_len(&in->timeout) +
 352                 ctdb_uint32_len(&in->flags);
 353 }
 354
 355 static void ctdb_event_request_run_push(struct ctdb_event_request_run *in,
 356                                         uint8_t *buf,
 357                                         size_t *npush)
 358 {
 359         size_t offset = 0, np;
 360
 361         ctdb_stringn_push(&in->component, buf+offset, &np);
 362         offset += np;
 363
 364         ctdb_stringn_push(&in->event, buf+offset, &np);
 365         offset += np;
 366
 367         ctdb_stringn_push(&in->args, buf+offset, &np);
 368         offset += np;
 369
 370         ctdb_uint32_push(&in->timeout, buf+offset, &np);
 371         offset += np;
 372
 373         ctdb_uint32_push(&in->flags, buf+offset, &np);
 374         offset += np;
 375
 376         *npush = offset;
 377 }
 378
 379 static int ctdb_event_request_run_pull(uint8_t *buf,
 380                                        size_t buflen,
 381                                        TALLOC_CTX *mem_ctx,
 382                                        struct ctdb_event_request_run **out,
 383                                        size_t *npull)
 384 {
 385         struct ctdb_event_request_run *value;
 386         size_t offset = 0, np;
 387         int ret;
 388
 389         value = talloc(mem_ctx, struct ctdb_event_request_run);
 390         if (value == NULL) {
 391                 return ENOMEM;
 392         }
 393
 394         ret = ctdb_stringn_pull(buf+offset,
 395                                 buflen-offset,
 396                                 value,
 397                                 &value->component,
 398                                 &np);
 399         if (ret != 0) {
 400                 goto fail;
 401         }
 402         offset += np;
 403
 404         ret = ctdb_stringn_pull(buf+offset,
 405                                 buflen-offset,
 406                                 value,
 407                                 &value->event,
 408                                 &np);
 409         if (ret != 0) {
 410                 goto fail;
 411         }
 412         offset += np;
 413
 414         ret = ctdb_stringn_pull(buf+offset,
 415                                 buflen-offset,
 416                                 value,
 417                                 &value->args,
 418                                 &np);
 419         if (ret != 0) {
 420                 goto fail;
 421         }
 422         offset += np;
 423
 424         ret = ctdb_uint32_pull(buf+offset,
 425                                buflen-offset,
 426                                &value->timeout,
 427                                &np);
 428         if (ret != 0) {
 429                 goto fail;
 430         }
 431         offset += np;
 432
 433         ret = ctdb_uint32_pull(buf+offset,
 434                                buflen-offset,
 435                                &value->flags,
 436                                &np);
 437         if (ret != 0) {
 438                 goto fail;
 439         }
 440         offset += np;
 441
 442         *out = value;
 443         *npull = offset;
 444
 445         return 0;
 446
 447 fail:
 448         talloc_free(value);
 449         return ret;
 450 }
 451
 452 static size_t ctdb_event_request_status_len(
 453                                 struct ctdb_event_request_status *in)
 454 {
 455         return ctdb_stringn_len(&in->component) +
 456                 ctdb_stringn_len(&in->event);
 457 }
 458
 459 static void ctdb_event_request_status_push(
 460                                 struct ctdb_event_request_status *in,
 461                                 uint8_t *buf,
 462                                 size_t *npush)
 463 {
 464         size_t offset = 0, np;
 465
 466         ctdb_stringn_push(&in->component, buf+offset, &np);
 467         offset += np;
 468
 469         ctdb_stringn_push(&in->event, buf+offset, &np);
 470         offset += np;
 471
 472         *npush = offset;
 473 }
 474
 475 static int ctdb_event_request_status_pull(
 476                                 uint8_t *buf,
 477                                 size_t buflen,
 478                                 TALLOC_CTX *mem_ctx,
 479                                 struct ctdb_event_request_status **out,
 480                                 size_t *npull)
 481 {
 482         struct ctdb_event_request_status *value;
 483         size_t offset = 0, np;
 484         int ret;
 485
 486         value = talloc(mem_ctx, struct ctdb_event_request_status);
 487         if (value == NULL) {
 488                 return ENOMEM;
 489         }
 490
 491         ret = ctdb_stringn_pull(buf+offset,
 492                                 buflen-offset,
 493                                 value,
 494                                 &value->component,
 495                                 &np);
 496         if (ret != 0) {
 497                 goto fail;
 498         }
 499         offset += np;
 500
 501         ret = ctdb_stringn_pull(buf+offset,
 502                                 buflen-offset,
 503                                 value,
 504                                 &value->event,
 505                                 &np);
 506         if (ret != 0) {
 507                 goto fail;
 508         }
 509         offset += np;
 510
 511         *out = value;
 512         *npull = offset;
 513
 514         return 0;
 515
 516 fail:
 517         talloc_free(value);
 518         return ret;
 519 }
 520
 521 static size_t ctdb_event_request_script_len(
 522                                 struct ctdb_event_request_script *in)
 523 {
 524         return ctdb_stringn_len(&in->component) +
 525                 ctdb_stringn_len(&in->script) +
 526                 ctdb_event_script_action_len(in->action);
 527 }
 528
 529 static void ctdb_event_request_script_push(
 530                                 struct ctdb_event_request_script *in,
 531                                 uint8_t *buf,
 532                                 size_t *npush)
 533 {
 534         size_t offset = 0, np;
 535
 536         ctdb_stringn_push(&in->component, buf+offset, &np);
 537         offset += np;
 538
 539         ctdb_stringn_push(&in->script, buf+offset, &np);
 540         offset += np;
 541
 542         ctdb_event_script_action_push(in->action, buf+offset, &np);
 543         offset += np;
 544
 545         *npush = offset;
 546 }
 547
 548 static int ctdb_event_request_script_pull(
 549                                 uint8_t *buf,
 550                                 size_t buflen,
 551                                 TALLOC_CTX *mem_ctx,
 552                                 struct ctdb_event_request_script **out,
 553                                 size_t *npull)
 554 {
 555         struct ctdb_event_request_script *value;
 556         size_t offset = 0, np;
 557         int ret;
 558
 559         value = talloc(mem_ctx, struct ctdb_event_request_script);
 560         if (value == NULL) {
 561                 return ENOMEM;
 562         }
 563
 564         ret = ctdb_stringn_pull(buf+offset,
 565                                 buflen-offset,
 566                                 value,
 567                                 &value->component,
 568                                 &np);
 569         if (ret != 0) {
 570                 goto fail;
 571         }
 572         offset += np;
 573
 574         ret = ctdb_stringn_pull(buf+offset,
 575                                 buflen-offset,
 576                                 value,
 577                                 &value->script,
 578                                 &np);
 579         if (ret != 0) {
 580                 goto fail;
 581         }
 582         offset += np;
 583
 584         ret = ctdb_event_script_action_pull(buf+offset,
 585                                             buflen-offset,
 586                                             &value->action,
 587                                             &np);
 588         if (ret != 0) {
 589                 goto fail;
 590         }
 591         offset += np;
 592
 593         *out = value;
 594         *npull = offset;
 595
 596         return 0;
 597
 598 fail:
 599         talloc_free(value);
 600         return ret;
 601 }
 602
 603 static size_t ctdb_event_reply_status_len(
 604                                 struct ctdb_event_reply_status *in)
 605 {
 606         return ctdb_int32_len(&in->summary) +
 607                 ctdb_event_script_list_len(in->script_list);
 608 }
 609
 610 static void ctdb_event_reply_status_push(
 611                                 struct ctdb_event_reply_status *in,
 612                                 uint8_t *buf,
 613                                 size_t *npush)
 614 {
 615         size_t offset = 0, np;
 616
 617         ctdb_int32_push(&in->summary, buf+offset, &np);
 618         offset += np;
 619
 620         ctdb_event_script_list_push(in->script_list, buf+offset, &np);
 621         offset += np;
 622
 623         *npush = offset;
 624 }
 625
 626 static int ctdb_event_reply_status_pull(
 627                                 uint8_t *buf,
 628                                 size_t buflen,
 629                                 TALLOC_CTX *mem_ctx,
 630                                 struct ctdb_event_reply_status **out,
 631                                 size_t *npull)
 632 {
 633         struct ctdb_event_reply_status *value;
 634         size_t offset = 0, np;
 635         int ret;
 636
 637         value = talloc(mem_ctx, struct ctdb_event_reply_status);
 638         if (value == NULL) {
 639                 return ENOMEM;
 640         }
 641
 642         ret = ctdb_int32_pull(buf+offset, buflen-offset, &value->summary, &np);
 643         if (ret != 0) {
 644                 goto fail;
 645         }
 646         offset += np;
 647
 648         ret = ctdb_event_script_list_pull(buf+offset,
 649                                           buflen-offset,
 650                                           value,
 651                                           &value->script_list,
 652                                           &np);
 653         if (ret != 0) {
 654                 goto fail;
 655         }
 656         offset += np;
 657
 658         *out = value;
 659         *npull = offset;
 660
 661         return 0;
 662
 663 fail:
 664         talloc_free(value);
 665         return ret;
 666 }
 667
 668 static size_t ctdb_event_header_len(struct ctdb_event_header *in)
 669 {
 670         return ctdb_uint32_len(&in->length) +
 671                 ctdb_uint32_len(&in->version) +
 672                 ctdb_uint32_len(&in->reqid);
 673 }
 674
 675 static void ctdb_event_header_push(struct ctdb_event_header *in,
 676                                    uint8_t *buf,
 677                                    size_t *npush)
 678 {
 679         size_t offset = 0, np;
 680
 681         ctdb_uint32_push(&in->length, buf+offset, &np);
 682         offset += np;
 683
 684         ctdb_uint32_push(&in->version, buf+offset, &np);
 685         offset += np;
 686
 687         ctdb_uint32_push(&in->reqid, buf+offset, &np);
 688         offset += np;
 689
 690         *npush = offset;
 691 }
 692
 693 static int ctdb_event_header_pull(uint8_t *buf,
 694                                   size_t buflen,
 695                                   struct ctdb_event_header *value,
 696                                   size_t *npull)
 697 {
 698         size_t offset = 0, np;
 699         int ret;
 700
 701         ret = ctdb_uint32_pull(buf+offset,
 702                                buflen-offset,
 703                                &value->length,
 704                                &np);
 705         if (ret != 0) {
 706                 return ret;
 707         }
 708         offset += np;
 709
 710         ret = ctdb_uint32_pull(buf+offset,
 711                                buflen-offset,
 712                                &value->version,
 713                                &np);
 714         if (ret != 0) {
 715                 return ret;
 716         }
 717         offset += np;
 718
 719         ret = ctdb_uint32_pull(buf+offset,
 720                                buflen-offset,
 721                                &value->reqid,
 722                                &np);
 723         if (ret != 0) {
 724                 return ret;
 725         }
 726         offset += np;
 727
 728         *npull = offset;
 729
 730         return 0;
 731 }
 732
 733 int ctdb_event_header_extract(uint8_t *buf,
 734                               size_t buflen,
 735                               struct ctdb_event_header *value)
 736 {
 737         size_t np;
 738
 739         return ctdb_event_header_pull(buf, buflen, value, &np);
 740 }
 741
 742 static size_t ctdb_event_request_data_len(struct ctdb_event_request *in)
 743 {
 744         size_t len;
 745
 746         len = ctdb_event_command_len(in->cmd);
 747
 748         switch (in->cmd) {
 749         case CTDB_EVENT_CMD_RUN:
 750                 len += ctdb_event_request_run_len(in->data.run);
 751                 break;
 752
 753         case CTDB_EVENT_CMD_STATUS:
 754                 len += ctdb_event_request_status_len(in->data.status);
 755                 break;
 756
 757         case CTDB_EVENT_CMD_SCRIPT:
 758                 len += ctdb_event_request_script_len(in->data.script);
 759                 break;
 760
 761         default:
 762                 break;
 763         }
 764
 765         return len;
 766 }
 767
 768 static void ctdb_event_request_data_push(struct ctdb_event_request *in,
 769                                          uint8_t *buf,
 770                                          size_t *npush)
 771 {
 772         size_t offset = 0, np;
 773
 774         ctdb_event_command_push(in->cmd, buf+offset, &np);
 775         offset += np;
 776
 777         switch (in->cmd) {
 778         case CTDB_EVENT_CMD_RUN:
 779                 ctdb_event_request_run_push(in->data.run, buf+offset, &np);
 780                 break;
 781
 782         case CTDB_EVENT_CMD_STATUS:
 783                 ctdb_event_request_status_push(in->data.status,
 784                                                buf+offset,
 785                                                &np);
 786                 break;
 787
 788         case CTDB_EVENT_CMD_SCRIPT:
 789                 ctdb_event_request_script_push(in->data.script,
 790                                                buf+offset,
 791                                                &np);
 792                 break;
 793         default:
 794                 np = 0;
 795                 break;
 796         }
 797         offset += np;
 798
 799         *npush = offset;
 800 }
 801
 802 static int ctdb_event_request_data_pull(uint8_t *buf,
 803                                         size_t buflen,
 804                                         TALLOC_CTX *mem_ctx,
 805                                         struct ctdb_event_request **out,
 806                                         size_t *npull)
 807 {
 808         struct ctdb_event_request *value;
 809         size_t offset = 0, np;
 810         int ret;
 811
 812         value = talloc(mem_ctx, struct ctdb_event_request);
 813         if (value == NULL) {
 814                 return ENOMEM;
 815         }
 816
 817         ret = ctdb_event_command_pull(buf+offset,
 818                                       buflen-offset,
 819                                       &value->cmd,
 820                                       &np);
 821         if (ret != 0) {
 822                 goto fail;
 823         }
 824         offset += np;
 825
 826         switch (value->cmd) {
 827         case CTDB_EVENT_CMD_RUN:
 828                 ret = ctdb_event_request_run_pull(buf+offset,
 829                                                   buflen-offset,
 830                                                   value,
 831                                                   &value->data.run,
 832                                                   &np);
 833                 break;
 834
 835         case CTDB_EVENT_CMD_STATUS:
 836                 ret = ctdb_event_request_status_pull(buf+offset,
 837                                                      buflen-offset,
 838                                                      value,
 839                                                      &value->data.status,
 840                                                      &np);
 841                 break;
 842
 843         case CTDB_EVENT_CMD_SCRIPT:
 844                 ret = ctdb_event_request_script_pull(buf+offset,
 845                                                      buflen-offset,
 846                                                      value,
 847                                                      &value->data.script,
 848                                                      &np);
 849                 break;
 850
 851         default:
 852                 np = 0;
 853                 break;
 854         }
 855
 856         if (ret != 0) {
 857                 goto fail;
 858         }
 859         offset += np;
 860
 861         *out = value;
 862         *npull = offset;
 863
 864         return 0;
 865
 866 fail:
 867         talloc_free(value);
 868         return ret;
 869 }
 870
 871 static size_t ctdb_event_reply_data_len(struct ctdb_event_reply *in)
 872 {
 873         size_t len;
 874
 875         len = ctdb_event_command_len(in->cmd) +
 876                 ctdb_int32_len(&in->result);
 877
 878         if (in->result != 0) {
 879                 goto done;
 880         }
 881
 882         switch (in->cmd) {
 883         case CTDB_EVENT_CMD_STATUS:
 884                 len += ctdb_event_reply_status_len(in->data.status);
 885                 break;
 886
 887         default:
 888                 break;
 889         }
 890
 891 done:
 892         return len;
 893 }
 894
 895 static void ctdb_event_reply_data_push(struct ctdb_event_reply *in,
 896                                        uint8_t *buf,
 897                                        size_t *npush)
 898 {
 899         size_t offset = 0, np;
 900
 901         ctdb_event_command_push(in->cmd, buf+offset, &np);
 902         offset += np;
 903
 904         ctdb_int32_push(&in->result, buf+offset, &np);
 905         offset += np;
 906
 907         if (in->result != 0) {
 908                 goto done;
 909         }
 910
 911         switch (in->cmd) {
 912         case CTDB_EVENT_CMD_STATUS:
 913                 ctdb_event_reply_status_push(in->data.status, buf+offset, &np);
 914                 break;
 915
 916         default:
 917                 np = 0;
 918                 break;
 919         }
 920         offset += np;
 921
 922 done:
 923         *npush = offset;
 924 }
 925
 926 static int ctdb_event_reply_data_pull(uint8_t *buf,
 927                                       size_t buflen,
 928                                       TALLOC_CTX *mem_ctx,
 929                                       struct ctdb_event_reply **out,
 930                                       size_t *npull)
 931 {
 932         struct ctdb_event_reply *value;
 933         size_t offset = 0, np;
 934         int ret;
 935
 936         value = talloc(mem_ctx, struct ctdb_event_reply);
 937         if (value == NULL) {
 938                 return ENOMEM;
 939         }
 940
 941         ret = ctdb_event_command_pull(buf+offset,
 942                                       buflen-offset,
 943                                       &value->cmd,
 944                                       &np);
 945         if (ret != 0) {
 946                 goto fail;
 947         }
 948         offset += np;
 949
 950         ret = ctdb_int32_pull(buf+offset, buflen-offset, &value->result, &np);
 951         if (ret != 0) {
 952                 goto fail;
 953         }
 954         offset += np;
 955
 956         if (value->result != 0) {
 957                 goto done;
 958         }
 959
 960         switch (value->cmd) {
 961         case CTDB_EVENT_CMD_STATUS:
 962                 ret = ctdb_event_reply_status_pull(buf+offset,
 963                                                    buflen-offset,
 964                                                    value,
 965                                                    &value->data.status,
 966                                                    &np);
 967                 break;
 968
 969         default:
 970                 np = 0;
 971                 break;
 972         }
 973
 974         if (ret != 0) {
 975                 goto fail;
 976         }
 977         offset += np;
 978
 979 done:
 980         *out = value;
 981         *npull = offset;
 982
 983         return 0;
 984
 985 fail:
 986         talloc_free(value);
 987         return ret;
 988 }
 989
 990 size_t ctdb_event_request_len(struct ctdb_event_header *h,
 991                               struct ctdb_event_request *in)
 992 {
 993         return ctdb_event_header_len(h) +
 994                 ctdb_event_request_data_len(in);
 995 }
 996
 997 int ctdb_event_request_push(struct ctdb_event_header *h,
 998                             struct ctdb_event_request *in,
 999                             uint8_t *buf,
1000                             size_t *buflen)
1001 {
1002         size_t len, offset = 0, np;
1003
1004         len = ctdb_event_request_len(h, in);
1005         if (*buflen < len) {
1006                 *buflen = len;
1007                 return EMSGSIZE;
1008         }
1009
1010         h->length = *buflen;
1011
1012         ctdb_event_header_push(h, buf+offset, &np);
1013         offset += np;
1014
1015         ctdb_event_request_data_push(in, buf+offset, &np);
1016         offset += np;
1017
1018         if (offset > *buflen) {
1019                 return EMSGSIZE;
1020         }
1021
1022         return 0;
1023 }
1024
1025 int ctdb_event_request_pull(uint8_t *buf,
1026                             size_t buflen,
1027                             struct ctdb_event_header *h,
1028                             TALLOC_CTX *mem_ctx,
1029                             struct ctdb_event_request **out)
1030 {
1031         size_t offset = 0, np;
1032         int ret;
1033
1034         ret = ctdb_event_header_pull(buf+offset, buflen-offset, h, &np);
1035         if (ret != 0) {
1036                 return ret;
1037         }
1038         offset += np;
1039
1040         ret = ctdb_event_request_data_pull(buf+offset,
1041                                            buflen-offset,
1042                                            mem_ctx,
1043                                            out,
1044                                            &np);
1045         if (ret != 0) {
1046                 return ret;
1047         }
1048         offset += np;
1049
1050         if (offset > buflen) {
1051                 return EMSGSIZE;
1052         }
1053
1054         return 0;
1055 }
1056
1057 size_t ctdb_event_reply_len(struct ctdb_event_header *h,
1058                             struct ctdb_event_reply *in)
1059 {
1060         return ctdb_event_header_len(h) +
1061                 ctdb_event_reply_data_len(in);
1062 }
1063
1064 int ctdb_event_reply_push(struct ctdb_event_header *h,
1065                           struct ctdb_event_reply *in,
1066                           uint8_t *buf,
1067                           size_t *buflen)
1068 {
1069         size_t len, offset = 0, np;
1070
1071         len = ctdb_event_reply_len(h, in);
1072         if (*buflen < len) {
1073                 *buflen = len;
1074                 return EMSGSIZE;
1075         }
1076
1077         h->length = *buflen;
1078
1079         ctdb_event_header_push(h, buf+offset, &np);
1080         offset += np;
1081
1082         ctdb_event_reply_data_push(in, buf+offset, &np);
1083         offset += np;
1084
1085         if (offset > *buflen) {
1086                 return EMSGSIZE;
1087         }
1088
1089         return 0;
1090 }
1091
1092 int ctdb_event_reply_pull(uint8_t *buf,
1093                           size_t buflen,
1094                           struct ctdb_event_header *h,
1095                           TALLOC_CTX *mem_ctx,
1096                           struct ctdb_event_reply **out)
1097 {
1098         size_t offset = 0, np;
1099         int ret;
1100
1101         ret = ctdb_event_header_pull(buf+offset, buflen-offset, h, &np);
1102         if (ret != 0) {
1103                 return ret;
1104         }
1105         offset += np;
1106
1107         ret = ctdb_event_reply_data_pull(buf+offset,
1108                                          buflen-offset,
1109                                          mem_ctx,
1110                                          out,
1111                                          &np);
1112         if (ret != 0) {
1113                 return ret;
1114         }
1115         offset += np;
1116
1117         if (offset > buflen) {
1118                 return EMSGSIZE;
1119         }
1120
1121         return 0;
1122 }