ctdb/protocol/protocol_call.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_call_wire {
  31         struct ctdb_req_header hdr;
  32         uint32_t flags;
  33         uint32_t db_id;
  34         uint32_t callid;
  35         uint32_t hopcount;
  36         uint32_t keylen;
  37         uint32_t calldatalen;
  38         uint8_t data[1]; /* key[] followed by calldata[] */
  39 };
  40
  41 struct ctdb_reply_call_wire {
  42         struct ctdb_req_header hdr;
  43         uint32_t status;
  44         uint32_t datalen;
  45         uint8_t  data[1];
  46 };
  47
  48 struct ctdb_reply_error_wire {
  49         struct ctdb_req_header hdr;
  50         uint32_t status;
  51         uint32_t msglen;
  52         uint8_t  msg[1];
  53 };
  54
  55 struct ctdb_req_dmaster_wire {
  56         struct ctdb_req_header hdr;
  57         uint32_t db_id;
  58         uint64_t rsn;
  59         uint32_t dmaster;
  60         uint32_t keylen;
  61         uint32_t datalen;
  62         uint8_t  data[1];
  63 };
  64
  65 struct ctdb_reply_dmaster_wire {
  66         struct ctdb_req_header hdr;
  67         uint32_t db_id;
  68         uint64_t rsn;
  69         uint32_t keylen;
  70         uint32_t datalen;
  71         uint8_t  data[1];
  72 };
  73
  74 size_t ctdb_req_call_len(struct ctdb_req_header *h, struct ctdb_req_call *c)
  75 {
  76         return offsetof(struct ctdb_req_call_wire, data) +
  77                 ctdb_tdb_data_len(c->key) + ctdb_tdb_data_len(c->calldata);
  78 }
  79
  80 int ctdb_req_call_push(struct ctdb_req_header *h, struct ctdb_req_call *c,
  81                        uint8_t *buf, size_t *buflen)
  82 {
  83         struct ctdb_req_call_wire *wire =
  84                 (struct ctdb_req_call_wire *)buf;
  85         size_t length;
  86
  87         if (c->key.dsize == 0) {
  88                 return EINVAL;
  89         }
  90
  91         length = ctdb_req_call_len(h, c);
  92         if (*buflen < length) {
  93                 *buflen = length;
  94                 return EMSGSIZE;
  95         }
  96
  97         h->length = *buflen;
  98         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
  99
 100         wire->flags = c->flags;
 101         wire->db_id = c->db_id;
 102         wire->callid = c->callid;
 103         wire->hopcount = c->hopcount;
 104         wire->keylen = ctdb_tdb_data_len(c->key);
 105         wire->calldatalen = ctdb_tdb_data_len(c->calldata);
 106         ctdb_tdb_data_push(c->key, wire->data);
 107         ctdb_tdb_data_push(c->calldata, wire->data + wire->keylen);
 108
 109         return 0;
 110 }
 111
 112 int ctdb_req_call_pull(uint8_t *buf, size_t buflen,
 113                        struct ctdb_req_header *h,
 114                        TALLOC_CTX *mem_ctx,
 115                        struct ctdb_req_call *c)
 116 {
 117         struct ctdb_req_call_wire *wire =
 118                 (struct ctdb_req_call_wire *)buf;
 119         size_t length;
 120         int ret;
 121
 122         length = offsetof(struct ctdb_req_call_wire, data);
 123         if (buflen < length) {
 124                 return EMSGSIZE;
 125         }
 126         if (wire->keylen > buflen || wire->calldatalen > buflen) {
 127                 return EMSGSIZE;
 128         }
 129         if (length + wire->keylen < length) {
 130                 return EMSGSIZE;
 131         }
 132         if (length + wire->keylen + wire->calldatalen < length) {
 133                 return EMSGSIZE;
 134         }
 135         if (buflen < length + wire->keylen + wire->calldatalen) {
 136                 return EMSGSIZE;
 137         }
 138
 139         if (h != NULL) {
 140                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
 141                 if (ret != 0) {
 142                         return ret;
 143                 }
 144         }
 145
 146         c->flags = wire->flags;
 147         c->db_id = wire->db_id;
 148         c->callid = wire->callid;
 149         c->hopcount = wire->hopcount;
 150
 151         ret = ctdb_tdb_data_pull(wire->data, wire->keylen, mem_ctx, &c->key);
 152         if (ret != 0) {
 153                 return ret;
 154         }
 155
 156         ret = ctdb_tdb_data_pull(wire->data + wire->keylen, wire->calldatalen,
 157                                  mem_ctx, &c->calldata);
 158         if (ret != 0) {
 159                 return ret;
 160         }
 161
 162         return 0;
 163 }
 164
 165 size_t ctdb_reply_call_len(struct ctdb_req_header *h,
 166                            struct ctdb_reply_call *c)
 167 {
 168         return offsetof(struct ctdb_reply_call_wire, data) +
 169                 ctdb_tdb_data_len(c->data);
 170 }
 171
 172 int ctdb_reply_call_push(struct ctdb_req_header *h, struct ctdb_reply_call *c,
 173                          uint8_t *buf, size_t *buflen)
 174 {
 175         struct ctdb_reply_call_wire *wire =
 176                 (struct ctdb_reply_call_wire *)buf;
 177         size_t length;
 178
 179         length = ctdb_reply_call_len(h, c);
 180         if (*buflen < length) {
 181                 *buflen = length;
 182                 return EMSGSIZE;
 183         }
 184
 185         h->length = *buflen;
 186         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
 187
 188         wire->status = c->status;
 189         wire->datalen = ctdb_tdb_data_len(c->data);
 190         ctdb_tdb_data_push(c->data, wire->data);
 191
 192         return 0;
 193 }
 194
 195 int ctdb_reply_call_pull(uint8_t *buf, size_t buflen,
 196                          struct ctdb_req_header *h,
 197                          TALLOC_CTX *mem_ctx,
 198                          struct ctdb_reply_call *c)
 199 {
 200         struct ctdb_reply_call_wire *wire =
 201                 (struct ctdb_reply_call_wire *)buf;
 202         size_t length;
 203         int ret;
 204
 205         length = offsetof(struct ctdb_reply_call_wire, data);
 206         if (buflen < length) {
 207                 return EMSGSIZE;
 208         }
 209         if (wire->datalen > buflen) {
 210                 return EMSGSIZE;
 211         }
 212         if (length + wire->datalen < length) {
 213                 return EMSGSIZE;
 214         }
 215         if (buflen < length + wire->datalen) {
 216                 return EMSGSIZE;
 217         }
 218
 219         if (h != NULL) {
 220                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
 221                 if (ret != 0) {
 222                         return ret;
 223                 }
 224         }
 225
 226         c->status = wire->status;
 227
 228         ret = ctdb_tdb_data_pull(wire->data, wire->datalen, mem_ctx, &c->data);
 229         if (ret != 0) {
 230                 return ret;
 231         }
 232
 233         return 0;
 234 }
 235
 236 size_t ctdb_reply_error_len(struct ctdb_req_header *h,
 237                             struct ctdb_reply_error *c)
 238 {
 239         return offsetof(struct ctdb_reply_error_wire, msg) +
 240                 ctdb_tdb_data_len(c->msg);
 241 }
 242
 243 int ctdb_reply_error_push(struct ctdb_req_header *h, struct ctdb_reply_error *c,
 244                           uint8_t *buf, size_t *buflen)
 245 {
 246         struct ctdb_reply_error_wire *wire =
 247                 (struct ctdb_reply_error_wire *)buf;
 248         size_t length;
 249
 250         length = ctdb_reply_error_len(h, c);
 251         if (*buflen < length) {
 252                 *buflen = length;
 253                 return EMSGSIZE;
 254         }
 255
 256         h->length = *buflen;
 257         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
 258
 259         wire->status = c->status;
 260         wire->msglen = ctdb_tdb_data_len(c->msg);
 261         ctdb_tdb_data_push(c->msg, wire->msg);
 262
 263         return 0;
 264 }
 265
 266 int ctdb_reply_error_pull(uint8_t *buf, size_t buflen,
 267                           struct ctdb_req_header *h,
 268                           TALLOC_CTX *mem_ctx,
 269                           struct ctdb_reply_error *c)
 270 {
 271         struct ctdb_reply_error_wire *wire =
 272                 (struct ctdb_reply_error_wire *)buf;
 273         size_t length;
 274         int ret;
 275
 276         length = offsetof(struct ctdb_reply_error_wire, msg);
 277         if (buflen < length) {
 278                 return EMSGSIZE;
 279         }
 280         if (wire->msglen > buflen) {
 281                 return EMSGSIZE;
 282         }
 283         if (length + wire->msglen < length) {
 284                 return EMSGSIZE;
 285         }
 286         if (buflen < length + wire->msglen) {
 287                 return EMSGSIZE;
 288         }
 289
 290         if (h != NULL) {
 291                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
 292                 if (ret != 0) {
 293                         return ret;
 294                 }
 295         }
 296
 297         c->status = wire->status;
 298
 299         ret = ctdb_tdb_data_pull(wire->msg, wire->msglen, mem_ctx, &c->msg);
 300         if (ret != 0) {
 301                 return ret;
 302         }
 303
 304         return 0;
 305 }
 306
 307 size_t ctdb_req_dmaster_len(struct ctdb_req_header *h,
 308                             struct ctdb_req_dmaster *c)
 309 {
 310         return offsetof(struct ctdb_req_dmaster_wire, data) +
 311                 ctdb_tdb_data_len(c->key) + ctdb_tdb_data_len(c->data);
 312 }
 313
 314 int ctdb_req_dmaster_push(struct ctdb_req_header *h, struct ctdb_req_dmaster *c,
 315                           uint8_t *buf, size_t *buflen)
 316 {
 317         struct ctdb_req_dmaster_wire *wire =
 318                 (struct ctdb_req_dmaster_wire *)buf;
 319         size_t length;
 320
 321         length = ctdb_req_dmaster_len(h, c);
 322         if (*buflen < length) {
 323                 *buflen = length;
 324                 return EMSGSIZE;
 325         }
 326
 327         h->length = *buflen;
 328         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
 329
 330         wire->db_id = c->db_id;
 331         wire->rsn = c->rsn;
 332         wire->dmaster = c->dmaster;
 333         wire->keylen = ctdb_tdb_data_len(c->key);
 334         wire->datalen = ctdb_tdb_data_len(c->data);
 335         ctdb_tdb_data_push(c->key, wire->data);
 336         ctdb_tdb_data_push(c->data, wire->data + wire->keylen);
 337
 338         return 0;
 339 }
 340
 341 int ctdb_req_dmaster_pull(uint8_t *buf, size_t buflen,
 342                           struct ctdb_req_header *h,
 343                           TALLOC_CTX *mem_ctx,
 344                           struct ctdb_req_dmaster *c)
 345 {
 346         struct ctdb_req_dmaster_wire *wire =
 347                 (struct ctdb_req_dmaster_wire *)buf;
 348         size_t length;
 349         int ret;
 350
 351         length = offsetof(struct ctdb_req_dmaster_wire, data);
 352         if (buflen < length) {
 353                 return EMSGSIZE;
 354         }
 355         if (wire->keylen > buflen || wire->datalen > buflen) {
 356                 return EMSGSIZE;
 357         }
 358         if (length + wire->keylen < length) {
 359                 return EMSGSIZE;
 360         }
 361         if (length + wire->keylen + wire->datalen < length) {
 362                 return EMSGSIZE;
 363         }
 364         if (buflen < length + wire->keylen + wire->datalen) {
 365                 return EMSGSIZE;
 366         }
 367
 368         if (h != NULL) {
 369                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
 370                 if (ret != 0) {
 371                         return ret;
 372                 }
 373         }
 374
 375         c->db_id = wire->db_id;
 376         c->rsn = wire->rsn;
 377         c->dmaster = wire->dmaster;
 378
 379         ret = ctdb_tdb_data_pull(wire->data, wire->keylen, mem_ctx, &c->key);
 380         if (ret != 0) {
 381                 return ret;
 382         }
 383
 384         ret = ctdb_tdb_data_pull(wire->data + wire->keylen, wire->datalen,
 385                                  mem_ctx, &c->data);
 386         if (ret != 0) {
 387                 return ret;
 388         }
 389
 390         return 0;
 391 }
 392
 393 size_t ctdb_reply_dmaster_len(struct ctdb_req_header *h,
 394                               struct ctdb_reply_dmaster *c)
 395 {
 396         return offsetof(struct ctdb_reply_dmaster_wire, data) +
 397                 ctdb_tdb_data_len(c->key) + ctdb_tdb_data_len(c->data);
 398 }
 399
 400 int ctdb_reply_dmaster_push(struct ctdb_req_header *h,
 401                             struct ctdb_reply_dmaster *c,
 402                             uint8_t *buf, size_t *buflen)
 403 {
 404         struct ctdb_reply_dmaster_wire *wire =
 405                 (struct ctdb_reply_dmaster_wire *)buf;
 406         size_t length;
 407
 408         length = ctdb_reply_dmaster_len(h, c);
 409         if (*buflen < length) {
 410                 *buflen = length;
 411                 return EMSGSIZE;
 412         }
 413
 414         h->length = *buflen;
 415         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
 416
 417         wire->db_id = c->db_id;
 418         wire->rsn = c->rsn;
 419         wire->keylen = ctdb_tdb_data_len(c->key);
 420         wire->datalen = ctdb_tdb_data_len(c->data);
 421         ctdb_tdb_data_push(c->key, wire->data);
 422         ctdb_tdb_data_push(c->data, wire->data + wire->keylen);
 423
 424         return 0;
 425 }
 426
 427 int ctdb_reply_dmaster_pull(uint8_t *buf, size_t buflen,
 428                             struct ctdb_req_header *h,
 429                             TALLOC_CTX *mem_ctx,
 430                             struct ctdb_reply_dmaster *c)
 431 {
 432         struct ctdb_reply_dmaster_wire *wire =
 433                 (struct ctdb_reply_dmaster_wire *)buf;
 434         size_t length;
 435         int ret;
 436
 437         length = offsetof(struct ctdb_reply_dmaster_wire, data);
 438         if (buflen < length) {
 439                 return EMSGSIZE;
 440         }
 441         if (wire->keylen > buflen || wire->datalen > buflen) {
 442                 return EMSGSIZE;
 443         }
 444         if (length + wire->keylen < length) {
 445                 return EMSGSIZE;
 446         }
 447         if (length + wire->keylen + wire->datalen < length) {
 448                 return EMSGSIZE;
 449         }
 450         if (buflen < length + wire->keylen + wire->datalen) {
 451                 return EMSGSIZE;
 452         }
 453
 454         if (h != NULL) {
 455                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
 456                 if (ret != 0) {
 457                         return ret;
 458                 }
 459         }
 460
 461         c->db_id = wire->db_id;
 462         c->rsn = wire->rsn;
 463
 464         ret = ctdb_tdb_data_pull(wire->data, wire->keylen, mem_ctx, &c->key);
 465         if (ret != 0) {
 466                 return ret;
 467         }
 468
 469         ret = ctdb_tdb_data_pull(wire->data + wire->keylen, wire->datalen,
 470                                  mem_ctx, &c->data);
 471         if (ret != 0) {
 472                 return ret;
 473         }
 474
 475         return 0;
 476 }