ctdb-protocol: Fix marshalling for uint32_t

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

diff --git a/ctdb/protocol/protocol_basic.c b/ctdb/protocol/protocol_basic.c
index df8e86ae072a5a268ed0bab317e18048d503c2d6..048dca44bcb8987f550c55cdc798971844bec66d 100644 (file)
--- a/ctdb/protocol/protocol_basic.c
+++ b/ctdb/protocol/protocol_basic.c
@@ -96,24 +96,25 @@ int ctdb_int32_pull(uint8_t *buf, size_t buflen, int32_t *out, size_t *npull)
        return 0;
 }
 
-size_t ctdb_uint32_len(uint32_t val)
+size_t ctdb_uint32_len(uint32_t *in)
 {
        return sizeof(uint32_t);
 }
 
-void ctdb_uint32_push(uint32_t val, uint8_t *buf)
+void ctdb_uint32_push(uint32_t *in, uint8_t *buf, size_t *npush)
 {
-       memcpy(buf, &val, sizeof(uint32_t));
+       memcpy(buf, in, sizeof(uint32_t));
+       *npush = sizeof(uint32_t);
 }
 
-int ctdb_uint32_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
-                    uint32_t *out)
+int ctdb_uint32_pull(uint8_t *buf, size_t buflen, uint32_t *out, size_t *npull)
 {
        if (buflen < sizeof(uint32_t)) {
                return EMSGSIZE;
        }
 
-       *out = *(uint32_t *)buf;
+       memcpy(out, buf, sizeof(uint32_t));
+       *npull = sizeof(uint32_t);
        return 0;
 }
 

diff --git a/ctdb/protocol/protocol_control.c b/ctdb/protocol/protocol_control.c
index b67ea91e3df508cf1e442a10f66597b32a3938c2..05a087747dbd5821d29979a356c96305d7112748 100644 (file)
--- a/ctdb/protocol/protocol_control.c
+++ b/ctdb/protocol/protocol_control.c
@@ -49,6 +49,7 @@ struct ctdb_reply_control_wire {
 static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
 {
        size_t len = 0;
+       uint32_t u32;
 
        if (cd == NULL) {
                return 0;
@@ -66,7 +67,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_GETDBPATH:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_GETVNNMAP:
@@ -80,7 +81,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_SET_DEBUG:
-               len = ctdb_uint32_len(cd->data.loglevel);
+               len = ctdb_uint32_len(&cd->data.loglevel);
                break;
 
        case CTDB_CONTROL_GET_DBMAP:
@@ -98,7 +99,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_SET_RECMODE:
-               len = ctdb_uint32_len(cd->data.recmode);
+               len = ctdb_uint32_len(&cd->data.recmode);
                break;
 
        case CTDB_CONTROL_STATISTICS_RESET:
@@ -130,15 +131,15 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_DBNAME:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_ENABLE_SEQNUM:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_UPDATE_SEQNUM:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DUMP_MEMORY:
@@ -151,7 +152,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_SET_RECMASTER:
-               len = ctdb_uint32_len(cd->data.recmaster);
+               len = ctdb_uint32_len(&cd->data.recmaster);
                break;
 
        case CTDB_CONTROL_FREEZE:
@@ -291,11 +292,11 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_SET_LMASTERROLE:
-               len = ctdb_uint32_len(cd->data.role);
+               len = ctdb_uint32_len(&cd->data.role);
                break;
 
        case CTDB_CONTROL_SET_RECMASTERROLE:
-               len = ctdb_uint32_len(cd->data.role);
+               len = ctdb_uint32_len(&cd->data.role);
                break;
 
        case CTDB_CONTROL_SET_BAN_STATE:
@@ -318,15 +319,16 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_DB_SEQNUM:
-               len = ctdb_uint32_len(cd->data.db_id) + ctdb_uint32_len(0);
+               u32 = 0;
+               len = ctdb_uint32_len(&cd->data.db_id) + ctdb_uint32_len(&u32);
                break;
 
        case CTDB_CONTROL_DB_SET_HEALTHY:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_GET_HEALTH:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
@@ -352,7 +354,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_SET_DB_READONLY:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_CHECK_SRVIDS:
@@ -363,11 +365,11 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_DB_STATISTICS:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_SET_DB_STICKY:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
@@ -388,18 +390,18 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_DETACH:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_GET_NODES_FILE:
                break;
 
        case CTDB_CONTROL_DB_FREEZE:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_THAW:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_START:
@@ -411,7 +413,7 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_PULL:
@@ -423,11 +425,11 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
@@ -441,13 +443,16 @@ static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
 static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                                       uint8_t *buf)
 {
+       size_t np, offset;
+       uint32_t u32;
+
        switch (cd->opcode) {
        case CTDB_CONTROL_PROCESS_EXISTS:
                ctdb_pid_push(cd->data.pid, buf);
                break;
 
        case CTDB_CONTROL_GETDBPATH:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_SETVNNMAP:
@@ -455,7 +460,7 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_SET_DEBUG:
-               ctdb_uint32_push(cd->data.loglevel, buf);
+               ctdb_uint32_push(&cd->data.loglevel, buf, &np);
                break;
 
        case CTDB_CONTROL_PULL_DB:
@@ -467,7 +472,7 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_SET_RECMODE:
-               ctdb_uint32_push(cd->data.recmode, buf);
+               ctdb_uint32_push(&cd->data.recmode, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_ATTACH:
@@ -490,19 +495,19 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_DBNAME:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_ENABLE_SEQNUM:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_UPDATE_SEQNUM:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_SET_RECMASTER:
-               ctdb_uint32_push(cd->data.recmaster, buf);
+               ctdb_uint32_push(&cd->data.recmaster, buf, &np);
                break;
 
        case CTDB_CONTROL_TCP_CLIENT:
@@ -582,11 +587,11 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_SET_LMASTERROLE:
-               ctdb_uint32_push(cd->data.role, buf);
+               ctdb_uint32_push(&cd->data.role, buf, &np);
                break;
 
        case CTDB_CONTROL_SET_RECMASTERROLE:
-               ctdb_uint32_push(cd->data.role, buf);
+               ctdb_uint32_push(&cd->data.role, buf, &np);
                break;
 
        case CTDB_CONTROL_SET_BAN_STATE:
@@ -606,16 +611,21 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_DB_SEQNUM:
-               ctdb_uint32_push(cd->data.db_id, buf);
-               ctdb_uint32_push(0, buf+4);
+               u32 = 0;
+               offset = 0;
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
+               offset += np;
+               ctdb_uint32_push(&u32, buf+offset, &np);
+               offset += np;
+               np = offset;
                break;
 
        case CTDB_CONTROL_DB_SET_HEALTHY:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_GET_HEALTH:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
@@ -635,7 +645,7 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_SET_DB_READONLY:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_CHECK_SRVIDS:
@@ -646,11 +656,11 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_DB_STATISTICS:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_SET_DB_STICKY:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_TRAVERSE_ALL_EXT:
@@ -662,15 +672,15 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_DETACH:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_FREEZE:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_THAW:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_START:
@@ -682,7 +692,7 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_PULL:
@@ -694,11 +704,11 @@ static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
@@ -712,6 +722,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                                      TALLOC_CTX *mem_ctx,
                                      struct ctdb_req_control_data *cd)
 {
+       size_t np, offset;
        uint32_t u32;
        int ret = 0;
 
@@ -724,8 +735,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GETDBPATH:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_SETVNNMAP:
@@ -734,8 +744,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_SET_DEBUG:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.loglevel);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
                break;
 
        case CTDB_CONTROL_PULL_DB:
@@ -749,8 +758,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_SET_RECMODE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.recmode);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.recmode, &np);
                break;
 
        case CTDB_CONTROL_DB_ATTACH:
@@ -777,23 +785,19 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_DBNAME:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_ENABLE_SEQNUM:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_UPDATE_SEQNUM:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_SET_RECMASTER:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.recmaster);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.recmaster, &np);
                break;
 
        case CTDB_CONTROL_TCP_CLIENT:
@@ -892,13 +896,11 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_SET_LMASTERROLE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.role);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
                break;
 
        case CTDB_CONTROL_SET_RECMASTERROLE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.role);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
                break;
 
        case CTDB_CONTROL_SET_BAN_STATE:
@@ -922,21 +924,23 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_DB_SEQNUM:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &cd->data.db_id);
+               offset = 0;
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                if (ret != 0) {
                        break;
                }
-               ret = ctdb_uint32_pull(buf+4, buflen-4, mem_ctx, &u32);
+               offset += np;
+               ret = ctdb_uint32_pull(buf+offset, buflen-offset, &u32, &np);
+               offset += np;
+               np = offset;
                break;
 
        case CTDB_CONTROL_DB_SET_HEALTHY:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_GET_HEALTH:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
@@ -960,8 +964,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_SET_DB_READONLY:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_CHECK_SRVIDS:
@@ -973,13 +976,11 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_DB_STATISTICS:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_SET_DB_STICKY:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_TRAVERSE_ALL_EXT:
@@ -993,18 +994,15 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_DETACH:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_FREEZE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_THAW:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_START:
@@ -1018,8 +1016,7 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                       &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_PULL:
@@ -1033,13 +1030,11 @@ static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
@@ -1082,7 +1077,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_DEBUG:
-               len = ctdb_uint32_len(cd->data.loglevel);
+               len = ctdb_uint32_len(&cd->data.loglevel);
                break;
 
        case CTDB_CONTROL_SET_DEBUG:
@@ -1109,7 +1104,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_ATTACH:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_SET_CALL:
@@ -1181,7 +1176,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_TUNABLE:
-               len = ctdb_uint32_len(cd->data.tun_value);
+               len = ctdb_uint32_len(&cd->data.tun_value);
                break;
 
        case CTDB_CONTROL_LIST_TUNABLES:
@@ -1203,7 +1198,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
 
        case CTDB_CONTROL_UPDATE_RECORD:
@@ -1245,7 +1240,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_CAPABILITIES:
-               len = ctdb_uint32_len(cd->data.caps);
+               len = ctdb_uint32_len(&cd->data.caps);
                break;
 
        case CTDB_CONTROL_RECD_PING:
@@ -1371,7 +1366,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_GET_RUNSTATE:
-               len = ctdb_uint32_len(cd->data.runstate);
+               len = ctdb_uint32_len(&cd->data.runstate);
                break;
 
        case CTDB_CONTROL_DB_DETACH:
@@ -1397,14 +1392,14 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_PULL:
-               len = ctdb_uint32_len(cd->data.num_records);
+               len = ctdb_uint32_len(&cd->data.num_records);
                break;
 
        case CTDB_CONTROL_DB_PUSH_START:
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               len = ctdb_uint32_len(cd->data.num_records);
+               len = ctdb_uint32_len(&cd->data.num_records);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
@@ -1412,7 +1407,7 @@ static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
-               len = ctdb_uint32_len(cd->data.db_id);
+               len = ctdb_uint32_len(&cd->data.db_id);
                break;
        }
 
@@ -1438,7 +1433,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_DEBUG:
-               ctdb_uint32_push(cd->data.loglevel, buf);
+               ctdb_uint32_push(&cd->data.loglevel, buf, &np);
                break;
 
        case CTDB_CONTROL_GET_DBMAP:
@@ -1453,7 +1448,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_ATTACH:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_GET_DBNAME:
@@ -1471,7 +1466,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_TUNABLE:
-               ctdb_uint32_push(cd->data.tun_value, buf);
+               ctdb_uint32_push(&cd->data.tun_value, buf, &np);
                break;
 
        case CTDB_CONTROL_LIST_TUNABLES:
@@ -1487,7 +1482,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
 
        case CTDB_CONTROL_UPTIME:
@@ -1499,7 +1494,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_CAPABILITIES:
-               ctdb_uint32_push(cd->data.caps, buf);
+               ctdb_uint32_push(&cd->data.caps, buf, &np);
                break;
 
        case CTDB_CONTROL_GET_PUBLIC_IPS:
@@ -1553,7 +1548,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_GET_RUNSTATE:
-               ctdb_uint32_push(cd->data.runstate, buf);
+               ctdb_uint32_push(&cd->data.runstate, buf, &np);
                break;
 
        case CTDB_CONTROL_GET_NODES_FILE:
@@ -1561,11 +1556,11 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_PULL:
-               ctdb_uint32_push(cd->data.num_records, buf);
+               ctdb_uint32_push(&cd->data.num_records, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               ctdb_uint32_push(cd->data.num_records, buf);
+               ctdb_uint32_push(&cd->data.num_records, buf, &np);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
@@ -1573,7 +1568,7 @@ static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
-               ctdb_uint32_push(cd->data.db_id, buf);
+               ctdb_uint32_push(&cd->data.db_id, buf, &np);
                break;
        }
 }
@@ -1604,8 +1599,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_DEBUG:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.loglevel);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
                break;
 
        case CTDB_CONTROL_GET_DBMAP:
@@ -1622,8 +1616,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_ATTACH:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_GET_DBNAME:
@@ -1643,8 +1636,8 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_TUNABLE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.tun_value);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.tun_value,
+                                      &np);
                break;
 
        case CTDB_CONTROL_LIST_TUNABLES:
@@ -1663,8 +1656,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
 
        case CTDB_CONTROL_UPTIME:
@@ -1678,8 +1670,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_CAPABILITIES:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                    &cd->data.caps);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.caps, &np);
                break;
 
        case CTDB_CONTROL_GET_PUBLIC_IPS:
@@ -1744,8 +1735,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_GET_RUNSTATE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.runstate);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.runstate, &np);
                break;
 
        case CTDB_CONTROL_GET_NODES_FILE:
@@ -1754,13 +1744,13 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_PULL:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.num_records);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
+                                      &np);
                break;
 
        case CTDB_CONTROL_DB_PUSH_CONFIRM:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.num_records);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
+                                      &np);
                break;
 
        case CTDB_CONTROL_DB_OPEN_FLAGS:
@@ -1768,8 +1758,7 @@ static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_CONTROL_DB_ATTACH_REPLICATED:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
-                                      &cd->data.db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
                break;
        }
 

diff --git a/ctdb/protocol/protocol_event.c b/ctdb/protocol/protocol_event.c
index db70d1773f1fe75750900b6d82f9a395b8244bf4..92b8a6ed2726398d746013b627cb3112641c7690 100644 (file)
--- a/ctdb/protocol/protocol_event.c
+++ b/ctdb/protocol/protocol_event.c
@@ -28,12 +28,17 @@
 
 static size_t ctdb_event_len(enum ctdb_event in)
 {
-       return ctdb_uint32_len((uint32_t)in);
+       uint32_t u32 = in;
+
+       return ctdb_uint32_len(&u32);
 }
 
 static void ctdb_event_push(enum ctdb_event in, uint8_t *buf)
 {
-       ctdb_uint32_push((uint32_t)in, buf);
+       size_t np;
+       uint32_t u32 = in;
+
+       ctdb_uint32_push(&u32, buf, &np);
 }
 
 static int ctdb_event_pull(uint8_t *buf, size_t buflen,
@@ -41,9 +46,10 @@ static int ctdb_event_pull(uint8_t *buf, size_t buflen,
 {
        uint32_t uint32_value;
        enum ctdb_event value;
+       size_t np;
        int ret;
 
-       ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
+       ret = ctdb_uint32_pull(buf, buflen, &uint32_value, &np);
        if (ret != 0) {
                return ret;
        }
@@ -115,12 +121,17 @@ static int ctdb_event_pull(uint8_t *buf, size_t buflen,
 
 static size_t ctdb_event_command_len(enum ctdb_event_command in)
 {
-       return ctdb_uint32_len((uint32_t)in);
+       uint32_t u32 = in;
+
+       return ctdb_uint32_len(&u32);
 }
 
 static void ctdb_event_command_push(enum ctdb_event_command in, uint8_t *buf)
 {
-       ctdb_uint32_push((uint32_t)in, buf);
+       size_t np;
+       uint32_t u32 = in;
+
+       ctdb_uint32_push(&u32, buf, &np);
 }
 
 static int ctdb_event_command_pull(uint8_t *buf, size_t buflen,
@@ -129,9 +140,10 @@ static int ctdb_event_command_pull(uint8_t *buf, size_t buflen,
 {
        uint32_t uint32_value;
        enum ctdb_event_command value;
+       size_t np;
        int ret;
 
-       ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
+       ret = ctdb_uint32_pull(buf, buflen, &uint32_value, &np);
        if (ret != 0) {
                return ret;
        }
@@ -167,13 +179,18 @@ static int ctdb_event_command_pull(uint8_t *buf, size_t buflen,
 
 static size_t ctdb_event_status_state_len(enum ctdb_event_status_state in)
 {
-       return ctdb_uint32_len((uint32_t)in);
+       uint32_t u32 = in;
+
+       return ctdb_uint32_len(&u32);
 }
 
 static void ctdb_event_status_state_push(enum ctdb_event_status_state in,
                                         uint8_t *buf)
 {
-       ctdb_uint32_push((uint32_t)in, buf);
+       size_t np;
+       uint32_t u32 = in;
+
+       ctdb_uint32_push(&u32, buf, &np);
 }
 
 static int ctdb_event_status_state_pull(uint8_t *buf, size_t buflen,
@@ -182,9 +199,10 @@ static int ctdb_event_status_state_pull(uint8_t *buf, size_t buflen,
 {
        uint32_t uint32_value;
        enum ctdb_event_status_state value;
+       size_t np;
        int ret;
 
-       ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &uint32_value);
+       ret = ctdb_uint32_pull(buf, buflen, &uint32_value, &np);
        if (ret != 0) {
                return ret;
        }
@@ -213,20 +231,20 @@ static int ctdb_event_status_state_pull(uint8_t *buf, size_t buflen,
 static size_t ctdb_event_request_run_len(struct ctdb_event_request_run *in)
 {
        return ctdb_event_len(in->event) +
-              ctdb_uint32_len(in->timeout) +
+              ctdb_uint32_len(&in->timeout) +
               ctdb_stringn_len(in->arg_str);
 }
 
 static void ctdb_event_request_run_push(struct ctdb_event_request_run *in,
                                        uint8_t *buf)
 {
-       size_t offset = 0;
+       size_t offset = 0, np;
 
        ctdb_event_push(in->event, buf);
        offset += ctdb_event_len(in->event);
 
-       ctdb_uint32_push(in->timeout, buf+offset);
-       offset += ctdb_uint32_len(in->timeout);
+       ctdb_uint32_push(&in->timeout, buf+offset, &np);
+       offset += np;
 
        ctdb_stringn_push(in->arg_str, buf+offset);
 }
@@ -236,7 +254,7 @@ static int ctdb_event_request_run_pull(uint8_t *buf, size_t buflen,
                                       struct ctdb_event_request_run **out)
 {
        struct ctdb_event_request_run *rdata;
-       size_t offset = 0;
+       size_t offset = 0, np;
        int ret;
 
        rdata = talloc(mem_ctx, struct ctdb_event_request_run);
@@ -250,12 +268,12 @@ static int ctdb_event_request_run_pull(uint8_t *buf, size_t buflen,
        }
        offset += ctdb_event_len(rdata->event);
 
-       ret = ctdb_uint32_pull(buf+offset, buflen-offset,
-                              rdata, &rdata->timeout);
+       ret = ctdb_uint32_pull(buf+offset, buflen-offset, &rdata->timeout,
+                              &np);
        if (ret != 0) {
                goto fail;
        }
-       offset += ctdb_uint32_len(rdata->timeout);
+       offset += np;
 
        ret = ctdb_stringn_pull(buf+offset, buflen-offset,
                                rdata, &rdata->arg_str);
@@ -707,34 +725,33 @@ static int ctdb_event_reply_data_pull(uint8_t *buf, size_t buflen,
 
 static size_t ctdb_event_header_len(struct ctdb_event_header *in)
 {
-       return ctdb_uint32_len(in->length) + ctdb_uint32_len(in->reqid);
+       return ctdb_uint32_len(&in->length) + ctdb_uint32_len(&in->reqid);
 }
 
 static void ctdb_event_header_push(struct ctdb_event_header *in, uint8_t *buf)
 {
-       size_t offset = 0;
+       size_t offset = 0, np;
 
-       ctdb_uint32_push(in->length, buf);
-       offset += ctdb_uint32_len(in->length);
+       ctdb_uint32_push(&in->length, buf, &np);
+       offset += np;
 
-       ctdb_uint32_push(in->reqid, buf+offset);
+       ctdb_uint32_push(&in->reqid, buf+offset, &np);
 }
 
 static int ctdb_event_header_pull(uint8_t *buf, size_t buflen,
                                  TALLOC_CTX *mem_ctx,
                                  struct ctdb_event_header *out)
 {
-       size_t offset = 0;
+       size_t offset = 0, np;
        int ret;
 
-       ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &out->length);
+       ret = ctdb_uint32_pull(buf, buflen, &out->length, &np);
        if (ret != 0) {
                return ret;
        }
-       offset += ctdb_uint32_len(out->length);
+       offset += np;
 
-       ret = ctdb_uint32_pull(buf+offset, buflen-offset,
-                              mem_ctx, &out->reqid);
+       ret = ctdb_uint32_pull(buf+offset, buflen-offset, &out->reqid, &np);
        if (ret != 0) {
                return ret;
        }

diff --git a/ctdb/protocol/protocol_message.c b/ctdb/protocol/protocol_message.c
index 3188c0ef5a87f7e9cc6b31a276c96c38e4d06d15..c0bea33d995c6d39dec11ad96f1ce459a9382581 100644 (file)
--- a/ctdb/protocol/protocol_message.c
+++ b/ctdb/protocol/protocol_message.c
@@ -41,7 +41,7 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
 
        switch (srvid) {
        case CTDB_SRVID_BANNING:
-               len = ctdb_uint32_len(mdata->pnn);
+               len = ctdb_uint32_len(&mdata->pnn);
                break;
 
        case CTDB_SRVID_ELECTION:
@@ -72,7 +72,7 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_DETACH_DATABASE:
-               len = ctdb_uint32_len(mdata->db_id);
+               len = ctdb_uint32_len(&mdata->db_id);
                break;
 
        case CTDB_SRVID_MEM_DUMP:
@@ -91,7 +91,7 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_REBALANCE_NODE:
-               len = ctdb_uint32_len(mdata->pnn);
+               len = ctdb_uint32_len(&mdata->pnn);
                break;
 
        case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
@@ -103,7 +103,7 @@ static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_DISABLE_IP_CHECK:
-               len = ctdb_uint32_len(mdata->timeout);
+               len = ctdb_uint32_len(&mdata->timeout);
                break;
 
        default:
@@ -117,9 +117,11 @@ 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)
 {
+       size_t np;
+
        switch (srvid) {
        case CTDB_SRVID_BANNING:
-               ctdb_uint32_push(mdata->pnn, buf);
+               ctdb_uint32_push(&mdata->pnn, buf, &np);
                break;
 
        case CTDB_SRVID_ELECTION:
@@ -150,7 +152,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_DETACH_DATABASE:
-               ctdb_uint32_push(mdata->db_id, buf);
+               ctdb_uint32_push(&mdata->db_id, buf, &np);
                break;
 
        case CTDB_SRVID_MEM_DUMP:
@@ -169,7 +171,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_REBALANCE_NODE:
-               ctdb_uint32_push(mdata->pnn, buf);
+               ctdb_uint32_push(&mdata->pnn, buf, &np);
                break;
 
        case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
@@ -181,7 +183,7 @@ static void ctdb_message_data_push(union ctdb_message_data *mdata,
                break;
 
        case CTDB_SRVID_DISABLE_IP_CHECK:
-               ctdb_uint32_push(mdata->timeout, buf);
+               ctdb_uint32_push(&mdata->timeout, buf, &np);
                break;
 
        default:
@@ -195,10 +197,11 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                                  union ctdb_message_data *mdata)
 {
        int ret = 0;
+       size_t np;
 
        switch (srvid) {
        case CTDB_SRVID_BANNING:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
+               ret = ctdb_uint32_pull(buf, buflen, &mdata->pnn, &np);
                break;
 
        case CTDB_SRVID_ELECTION:
@@ -233,7 +236,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_SRVID_DETACH_DATABASE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->db_id);
+               ret = ctdb_uint32_pull(buf, buflen, &mdata->db_id, &np);
                break;
 
        case CTDB_SRVID_MEM_DUMP:
@@ -255,7 +258,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_SRVID_REBALANCE_NODE:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
+               ret = ctdb_uint32_pull(buf, buflen, &mdata->pnn, &np);
                break;
 
        case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
@@ -269,7 +272,7 @@ static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
                break;
 
        case CTDB_SRVID_DISABLE_IP_CHECK:
-               ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->timeout);
+               ret = ctdb_uint32_pull(buf, buflen, &mdata->timeout, &np);
                break;
 
        default:

diff --git a/ctdb/protocol/protocol_private.h b/ctdb/protocol/protocol_private.h
index f9190d117a27639961003175e472781b075ca24e..632fb4fbf20a29856823113da8257b2c08aa1016 100644 (file)
--- a/ctdb/protocol/protocol_private.h
+++ b/ctdb/protocol/protocol_private.h
@@ -39,10 +39,10 @@ size_t ctdb_int32_len(int32_t *in);
 void ctdb_int32_push(int32_t *in, uint8_t *buf, size_t *npush);
 int ctdb_int32_pull(uint8_t *buf, size_t buflen, int32_t *out, size_t *npull);
 
-size_t ctdb_uint32_len(uint32_t val);
-void ctdb_uint32_push(uint32_t val, uint8_t *buf);
-int ctdb_uint32_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
-                    uint32_t *out);
+size_t ctdb_uint32_len(uint32_t *in);
+void ctdb_uint32_push(uint32_t *in, uint8_t *buf, size_t *npush);
+int ctdb_uint32_pull(uint8_t *buf, size_t buflen, uint32_t *out,
+                    size_t *npull);
 
 size_t ctdb_uint64_len(uint64_t val);
 void ctdb_uint64_push(uint64_t val, uint8_t *buf);

diff --git a/ctdb/tests/src/protocol_basic_test.c b/ctdb/tests/src/protocol_basic_test.c
index 2257e4677822bcb6e38e173014375b27056e1a6a..f82be99b57287540ddffb5cdf4e17b4993fd323b 100644 (file)
--- a/ctdb/tests/src/protocol_basic_test.c
+++ b/ctdb/tests/src/protocol_basic_test.c
@@ -28,20 +28,7 @@
 PROTOCOL_TYPE1_TEST(uint8_t, ctdb_uint8);
 PROTOCOL_TYPE1_TEST(uint16_t, ctdb_uint16);
 PROTOCOL_TYPE1_TEST(int32_t, ctdb_int32);
-
-static void test_ctdb_uint32(void)
-{
-       uint32_t p1, p2;
-       size_t buflen;
-       int ret;
-
-       p1 = rand32();
-       buflen = ctdb_uint32_len(p1);
-       ctdb_uint32_push(p1, BUFFER);
-       ret = ctdb_uint32_pull(BUFFER, buflen, NULL, &p2);
-       assert(ret == 0);
-       assert(p1 == p2);
-}
+PROTOCOL_TYPE1_TEST(uint32_t, ctdb_uint32);
 
 static void test_ctdb_uint64(void)
 {
@@ -127,8 +114,8 @@ int main(int argc, char *argv[])
        TEST_FUNC(ctdb_uint8)();
        TEST_FUNC(ctdb_uint16)();
        TEST_FUNC(ctdb_int32)();
+       TEST_FUNC(ctdb_uint32)();
 
-       test_ctdb_uint32();
        test_ctdb_uint64();
        test_ctdb_double();
 

diff --git a/ctdb/tests/src/protocol_common.c b/ctdb/tests/src/protocol_common.c
index b3aa26bfbe3e9184e0d4f9884d5b8c5616099865..59ee01b5d6466f24fff972d0bf07a52918ec8606 100644 (file)
--- a/ctdb/tests/src/protocol_common.c
+++ b/ctdb/tests/src/protocol_common.c
@@ -118,6 +118,16 @@ void verify_ctdb_int32(int32_t *p1, int32_t *p2)
        assert(*p1 == *p2);
 }
 
+void fill_ctdb_uint32(uint32_t *p)
+{
+       *p = rand32();
+}
+
+void verify_ctdb_uint32(uint32_t *p1, uint32_t *p2)
+{
+       assert(*p1 == *p2);
+}
+
 void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **out)
 {
        char *p;

diff --git a/ctdb/tests/src/protocol_common.h b/ctdb/tests/src/protocol_common.h
index 0b535563ee8a82301a42a6cbae74e6518ac21486..32c8332ea972ad3a8f4e35c08042bf4d23fd49af 100644 (file)
--- a/ctdb/tests/src/protocol_common.h
+++ b/ctdb/tests/src/protocol_common.h
@@ -161,6 +161,9 @@ void verify_ctdb_uint16(uint16_t *p1, uint16_t *p2);
 void fill_ctdb_int32(int32_t *p);
 void verify_ctdb_int32(int32_t *p1, int32_t *p2);
 
+void fill_ctdb_uint32(uint32_t *p);
+void verify_ctdb_uint32(uint32_t *p1, uint32_t *p2);
+
 void fill_ctdb_string(TALLOC_CTX *mem_ctx, const char **out);
 void verify_ctdb_string(const char *p1, const char *p2);