ctdb-protocol: Add a generic packet header

[vlendec/samba-autobuild/.git] / ctdb / protocol / protocol_message.c

diff --git a/ctdb/protocol/protocol_message.c b/ctdb/protocol/protocol_message.c
index 1fc7fcf70294fa5288c1835ece03213f82b58161..19c1f162d0c17446d1d21c2cbff6588fb3f1f5f2 100644 (file)
--- a/ctdb/protocol/protocol_message.c
+++ b/ctdb/protocol/protocol_message.c
@@ -27,12 +27,6 @@
 #include "protocol_api.h"
 #include "protocol_private.h"
 
-struct ctdb_req_message_wire {
-       struct ctdb_req_header hdr;
-       uint64_t srvid;
-       uint32_t datalen;
-       uint8_t data[1];
-};
 
 static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
                                    uint64_t srvid)
@@ -79,6 +73,12 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
                len = ctdb_srvid_message_len(mdata->msg);
                break;
 
+       case CTDB_SRVID_GETLOG:
+               break;
+
+       case CTDB_SRVID_CLEARLOG:
+               break;
+
        case CTDB_SRVID_PUSH_NODE_FLAGS:
                len = ctdb_node_flag_change_len(mdata->flag_change);
                break;
@@ -115,9 +115,10 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
 }
 
 static void ctdb_message_data_push(union ctdb_message_data *mdata,
-                                  uint64_t srvid, uint8_t *buf)
+                                  uint64_t srvid, uint8_t *buf,
+                                  size_t *npush)
 {
-       size_t np;
+       size_t np = 0;
 
        switch (srvid) {
        case CTDB_SRVID_BANNING:
@@ -125,7 +126,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_ELECTION:
-               ctdb_election_message_push(mdata->election, buf);
+               ctdb_election_message_push(mdata->election, buf, &np);
                break;
 
        case CTDB_SRVID_RECONFIGURE:
@@ -144,7 +145,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_RECD_UPDATE_IP:
-               ctdb_public_ip_push(mdata->pubip, buf);
+               ctdb_public_ip_push(mdata->pubip, buf, &np);
                break;
 
        case CTDB_SRVID_VACUUM_FETCH:
@@ -156,7 +157,13 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_MEM_DUMP:
-               ctdb_srvid_message_push(mdata->msg, buf);
+               ctdb_srvid_message_push(mdata->msg, buf, &np);
+               break;
+
+       case CTDB_SRVID_GETLOG:
+               break;
+
+       case CTDB_SRVID_CLEARLOG:
                break;
 
        case CTDB_SRVID_PUSH_NODE_FLAGS:
@@ -167,7 +174,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_TAKEOVER_RUN:
-               ctdb_srvid_message_push(mdata->msg, buf);
+               ctdb_srvid_message_push(mdata->msg, buf, &np);
                break;
 
        case CTDB_SRVID_REBALANCE_NODE:
@@ -175,11 +182,11 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
-               ctdb_disable_message_push(mdata->disable, buf);
+               ctdb_disable_message_push(mdata->disable, buf, &np);
                break;
 
        case CTDB_SRVID_DISABLE_RECOVERIES:
-               ctdb_disable_message_push(mdata->disable, buf);
+               ctdb_disable_message_push(mdata->disable, buf, &np);
                break;
 
        case CTDB_SRVID_DISABLE_IP_CHECK:
@@ -190,14 +197,17 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                ctdb_tdb_data_push(&mdata->data, buf, &np);
                break;
        }
+
+       *npush = np;
 }
 
 static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                                  uint64_t srvid, TALLOC_CTX *mem_ctx,
-                                 union ctdb_message_data *mdata)
+                                 union ctdb_message_data *mdata,
+                                 size_t *npull)
 {
        int ret = 0;
-       size_t np;
+       size_t np = 0;
 
        switch (srvid) {
        case CTDB_SRVID_BANNING:
@@ -206,7 +216,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 
        case CTDB_SRVID_ELECTION:
                ret = ctdb_election_message_pull(buf, buflen, mem_ctx,
-                                                &mdata->election);
+                                                &mdata->election, &np);
                break;
 
        case CTDB_SRVID_RECONFIGURE:
@@ -229,7 +239,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 
        case CTDB_SRVID_RECD_UPDATE_IP:
                ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
-                                         &mdata->pubip);
+                                         &mdata->pubip, &np);
                break;
 
        case CTDB_SRVID_VACUUM_FETCH:
@@ -243,7 +253,13 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 
        case CTDB_SRVID_MEM_DUMP:
                ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
-                                             &mdata->msg);
+                                             &mdata->msg, &np);
+               break;
+
+       case CTDB_SRVID_GETLOG:
+               break;
+
+       case CTDB_SRVID_CLEARLOG:
                break;
 
        case CTDB_SRVID_PUSH_NODE_FLAGS:
@@ -256,7 +272,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 
        case CTDB_SRVID_TAKEOVER_RUN:
                ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
-                                             &mdata->msg);
+                                             &mdata->msg, &np);
                break;
 
        case CTDB_SRVID_REBALANCE_NODE:
@@ -265,12 +281,12 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
 
        case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
                ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
-                                               &mdata->disable);
+                                               &mdata->disable, &np);
                break;
 
        case CTDB_SRVID_DISABLE_RECOVERIES:
                ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
-                                               &mdata->disable);
+                                               &mdata->disable, &np);
                break;
 
        case CTDB_SRVID_DISABLE_IP_CHECK:
@@ -283,36 +299,51 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                break;
        }
 
-       return ret;
+       if (ret != 0) {
+               return ret;
+       }
+
+       *npull = np;
+       return 0;
 }
 
 size_t ctdb_req_message_len(struct ctdb_req_header *h,
                            struct ctdb_req_message *c)
 {
-       return offsetof(struct ctdb_req_message_wire, data) +
-               ctdb_message_data_len(&c->data, c->srvid);
+       uint32_t u32 = ctdb_message_data_len(&c->data, c->srvid);
+
+       return ctdb_req_header_len(h) +
+               ctdb_uint64_len(&c->srvid) +
+               ctdb_uint32_len(&u32) + u32;
 }
 
 int ctdb_req_message_push(struct ctdb_req_header *h,
-                         struct ctdb_req_message *message,
+                         struct ctdb_req_message *c,
                          uint8_t *buf, size_t *buflen)
 {
-       struct ctdb_req_message_wire *wire =
-               (struct ctdb_req_message_wire *)buf;
+       size_t offset = 0, np;
        size_t length;
+       uint32_t u32;
 
-       length = ctdb_req_message_len(h, message);
+       length = ctdb_req_message_len(h, c);
        if (*buflen < length) {
                *buflen = length;
                return EMSGSIZE;
        }
 
        h->length = *buflen;
-       ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
+       ctdb_req_header_push(h, buf+offset, &np);
+       offset += np;
+
+       ctdb_uint64_push(&c->srvid, buf+offset, &np);
+       offset += np;
 
-       wire->srvid = message->srvid;
-       wire->datalen = ctdb_message_data_len(&message->data, message->srvid);
-       ctdb_message_data_push(&message->data, message->srvid, wire->data);
+       u32 = ctdb_message_data_len(&c->data, c->srvid);
+       ctdb_uint32_push(&u32, buf+offset, &np);
+       offset += np;
+
+       ctdb_message_data_push(&c->data, c->srvid, buf+offset, &np);
+       offset += np;
 
        return 0;
 }
@@ -322,65 +353,77 @@ int ctdb_req_message_pull(uint8_t *buf, size_t buflen,
                          TALLOC_CTX *mem_ctx,
                          struct ctdb_req_message *c)
 {
-       struct ctdb_req_message_wire *wire =
-               (struct ctdb_req_message_wire *)buf;
-       size_t length;
+       struct ctdb_req_header header;
+       size_t offset = 0, np;
+       uint32_t u32;
        int ret;
 
-       length = offsetof(struct ctdb_req_message_wire, data);
-       if (buflen < length) {
-               return EMSGSIZE;
+       ret = ctdb_req_header_pull(buf+offset, buflen-offset, &header, &np);
+       if (ret != 0) {
+               return ret;
        }
-       if (wire->datalen > buflen) {
-               return EMSGSIZE;
+       offset += np;
+
+       if (h != NULL) {
+               *h = header;
        }
-       if (length + wire->datalen < length) {
-               return EMSGSIZE;
+
+       ret = ctdb_uint64_pull(buf+offset, buflen-offset, &c->srvid, &np);
+       if (ret != 0) {
+               return ret;
+       }
+       offset += np;
+
+       ret = ctdb_uint32_pull(buf+offset, buflen-offset, &u32, &np);
+       if (ret != 0) {
+               return ret;
        }
-       if (buflen < length + wire->datalen) {
+       offset += np;
+
+       if (buflen-offset < u32) {
                return EMSGSIZE;
        }
 
-       if (h != NULL) {
-               ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
-               if (ret != 0) {
-                       return ret;
-               }
+       ret = ctdb_message_data_pull(buf+offset, u32, c->srvid,
+                                    mem_ctx, &c->data, &np);
+       if (ret != 0) {
+               return ret;
        }
+       offset += np;
 
-       c->srvid = wire->srvid;
-       ret = ctdb_message_data_pull(wire->data, wire->datalen, wire->srvid,
-                                    mem_ctx, &c->data);
        return ret;
 }
 
 size_t ctdb_req_message_data_len(struct ctdb_req_header *h,
                                 struct ctdb_req_message_data *c)
 {
-       return offsetof(struct ctdb_req_message_wire, data) +
-               ctdb_tdb_data_len(&c->data);
+       return ctdb_req_header_len(h) +
+               ctdb_uint64_len(&c->srvid) +
+               ctdb_tdb_datan_len(&c->data);
 }
 
 int ctdb_req_message_data_push(struct ctdb_req_header *h,
-                              struct ctdb_req_message_data *message,
+                              struct ctdb_req_message_data *c,
                               uint8_t *buf, size_t *buflen)
 {
-       struct ctdb_req_message_wire *wire =
-               (struct ctdb_req_message_wire *)buf;
-       size_t length, np;
+       size_t offset = 0, np;
+       size_t length;
 
-       length = ctdb_req_message_data_len(h, message);
+       length = ctdb_req_message_data_len(h, c);
        if (*buflen < length) {
                *buflen = length;
                return EMSGSIZE;
        }
 
        h->length = *buflen;
-       ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
+       ctdb_req_header_push(h, buf+offset, &np);
+       offset += np;
 
-       wire->srvid = message->srvid;
-       wire->datalen = ctdb_tdb_data_len(&message->data);
-       ctdb_tdb_data_push(&message->data, wire->data, &np);
+       ctdb_uint64_push(&c->srvid, buf+offset, &np);
+       offset += np;
+
+       ctdb_tdb_datan_push(&c->data, buf+offset, &np);
+       offset += np;
 
        return 0;
 }
@@ -390,39 +433,32 @@ int ctdb_req_message_data_pull(uint8_t *buf, size_t buflen,
                               TALLOC_CTX *mem_ctx,
                               struct ctdb_req_message_data *c)
 {
-       struct ctdb_req_message_wire *wire =
-               (struct ctdb_req_message_wire *)buf;
-       size_t length, np;
+       struct ctdb_req_header header;
+       size_t offset = 0, np;
        int ret;
 
-       length = offsetof(struct ctdb_req_message_wire, data);
-       if (buflen < length) {
-               return EMSGSIZE;
-       }
-       if (wire->datalen > buflen) {
-               return EMSGSIZE;
-       }
-       if (length + wire->datalen < length) {
-               return EMSGSIZE;
-       }
-       if (buflen < length + wire->datalen) {
-               return EMSGSIZE;
+       ret = ctdb_req_header_pull(buf+offset, buflen-offset, &header, &np);
+       if (ret != 0) {
+               return ret;
        }
+       offset += np;
 
        if (h != NULL) {
-               ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
-               if (ret != 0) {
-                       return ret;
-               }
+               *h = header;
        }
 
-       c->srvid = wire->srvid;
+       ret = ctdb_uint64_pull(buf+offset, buflen-offset, &c->srvid, &np);
+       if (ret != 0) {
+               return ret;
+       }
+       offset += np;
 
-       ret = ctdb_tdb_data_pull(wire->data, wire->datalen,
-                                mem_ctx, &c->data, &np);
+       ret = ctdb_tdb_datan_pull(buf+offset, buflen-offset,
+                                 mem_ctx, &c->data, &np);
        if (ret != 0) {
                return ret;
        }
+       offset += np;
 
        return 0;
 }