2 CTDB protocol marshalling
4 Copyright (C) Amitay Isaacs 2015
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.
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.
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/>.
21 #include "system/network.h"
27 #include "protocol_api.h"
28 #include "protocol_private.h"
30 struct ctdb_req_message_wire {
31 struct ctdb_req_header hdr;
37 static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
43 case CTDB_SRVID_BANNING:
44 len = ctdb_uint32_len(&mdata->pnn);
47 case CTDB_SRVID_ELECTION:
48 len = ctdb_election_message_len(mdata->election);
51 case CTDB_SRVID_RECONFIGURE:
54 case CTDB_SRVID_RELEASE_IP:
55 len = ctdb_string_len(&mdata->ipaddr);
58 case CTDB_SRVID_TAKE_IP:
59 len = ctdb_string_len(&mdata->ipaddr);
62 case CTDB_SRVID_SET_NODE_FLAGS:
63 len = ctdb_node_flag_change_len(mdata->flag_change);
66 case CTDB_SRVID_RECD_UPDATE_IP:
67 len = ctdb_public_ip_len(mdata->pubip);
70 case CTDB_SRVID_VACUUM_FETCH:
71 len = ctdb_rec_buffer_len(mdata->recbuf);
74 case CTDB_SRVID_DETACH_DATABASE:
75 len = ctdb_uint32_len(&mdata->db_id);
78 case CTDB_SRVID_MEM_DUMP:
79 len = ctdb_srvid_message_len(mdata->msg);
82 case CTDB_SRVID_PUSH_NODE_FLAGS:
83 len = ctdb_node_flag_change_len(mdata->flag_change);
86 case CTDB_SRVID_RELOAD_NODES:
89 case CTDB_SRVID_TAKEOVER_RUN:
90 len = ctdb_srvid_message_len(mdata->msg);
93 case CTDB_SRVID_REBALANCE_NODE:
94 len = ctdb_uint32_len(&mdata->pnn);
97 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
98 len = ctdb_disable_message_len(mdata->disable);
101 case CTDB_SRVID_DISABLE_RECOVERIES:
102 len = ctdb_disable_message_len(mdata->disable);
105 case CTDB_SRVID_DISABLE_IP_CHECK:
106 len = ctdb_uint32_len(&mdata->timeout);
110 len = ctdb_tdb_data_len(&mdata->data);
117 static void ctdb_message_data_push(union ctdb_message_data *mdata,
118 uint64_t srvid, uint8_t *buf)
123 case CTDB_SRVID_BANNING:
124 ctdb_uint32_push(&mdata->pnn, buf, &np);
127 case CTDB_SRVID_ELECTION:
128 ctdb_election_message_push(mdata->election, buf);
131 case CTDB_SRVID_RECONFIGURE:
134 case CTDB_SRVID_RELEASE_IP:
135 ctdb_string_push(&mdata->ipaddr, buf, &np);
138 case CTDB_SRVID_TAKE_IP:
139 ctdb_string_push(&mdata->ipaddr, buf, &np);
142 case CTDB_SRVID_SET_NODE_FLAGS:
143 ctdb_node_flag_change_push(mdata->flag_change, buf);
146 case CTDB_SRVID_RECD_UPDATE_IP:
147 ctdb_public_ip_push(mdata->pubip, buf);
150 case CTDB_SRVID_VACUUM_FETCH:
151 ctdb_rec_buffer_push(mdata->recbuf, buf, &np);
154 case CTDB_SRVID_DETACH_DATABASE:
155 ctdb_uint32_push(&mdata->db_id, buf, &np);
158 case CTDB_SRVID_MEM_DUMP:
159 ctdb_srvid_message_push(mdata->msg, buf);
162 case CTDB_SRVID_PUSH_NODE_FLAGS:
163 ctdb_node_flag_change_push(mdata->flag_change, buf);
166 case CTDB_SRVID_RELOAD_NODES:
169 case CTDB_SRVID_TAKEOVER_RUN:
170 ctdb_srvid_message_push(mdata->msg, buf);
173 case CTDB_SRVID_REBALANCE_NODE:
174 ctdb_uint32_push(&mdata->pnn, buf, &np);
177 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
178 ctdb_disable_message_push(mdata->disable, buf);
181 case CTDB_SRVID_DISABLE_RECOVERIES:
182 ctdb_disable_message_push(mdata->disable, buf);
185 case CTDB_SRVID_DISABLE_IP_CHECK:
186 ctdb_uint32_push(&mdata->timeout, buf, &np);
190 ctdb_tdb_data_push(&mdata->data, buf, &np);
195 static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
196 uint64_t srvid, TALLOC_CTX *mem_ctx,
197 union ctdb_message_data *mdata)
203 case CTDB_SRVID_BANNING:
204 ret = ctdb_uint32_pull(buf, buflen, &mdata->pnn, &np);
207 case CTDB_SRVID_ELECTION:
208 ret = ctdb_election_message_pull(buf, buflen, mem_ctx,
212 case CTDB_SRVID_RECONFIGURE:
215 case CTDB_SRVID_RELEASE_IP:
216 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr,
220 case CTDB_SRVID_TAKE_IP:
221 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr,
225 case CTDB_SRVID_SET_NODE_FLAGS:
226 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
227 &mdata->flag_change);
230 case CTDB_SRVID_RECD_UPDATE_IP:
231 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
235 case CTDB_SRVID_VACUUM_FETCH:
236 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
237 &mdata->recbuf, &np);
240 case CTDB_SRVID_DETACH_DATABASE:
241 ret = ctdb_uint32_pull(buf, buflen, &mdata->db_id, &np);
244 case CTDB_SRVID_MEM_DUMP:
245 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
249 case CTDB_SRVID_PUSH_NODE_FLAGS:
250 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
251 &mdata->flag_change);
254 case CTDB_SRVID_RELOAD_NODES:
257 case CTDB_SRVID_TAKEOVER_RUN:
258 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
262 case CTDB_SRVID_REBALANCE_NODE:
263 ret = ctdb_uint32_pull(buf, buflen, &mdata->pnn, &np);
266 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
267 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
271 case CTDB_SRVID_DISABLE_RECOVERIES:
272 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
276 case CTDB_SRVID_DISABLE_IP_CHECK:
277 ret = ctdb_uint32_pull(buf, buflen, &mdata->timeout, &np);
281 ret = ctdb_tdb_data_pull(buf, buflen, mem_ctx, &mdata->data,
289 size_t ctdb_req_message_len(struct ctdb_req_header *h,
290 struct ctdb_req_message *c)
292 return offsetof(struct ctdb_req_message_wire, data) +
293 ctdb_message_data_len(&c->data, c->srvid);
296 int ctdb_req_message_push(struct ctdb_req_header *h,
297 struct ctdb_req_message *message,
298 uint8_t *buf, size_t *buflen)
300 struct ctdb_req_message_wire *wire =
301 (struct ctdb_req_message_wire *)buf;
304 length = ctdb_req_message_len(h, message);
305 if (*buflen < length) {
311 ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
313 wire->srvid = message->srvid;
314 wire->datalen = ctdb_message_data_len(&message->data, message->srvid);
315 ctdb_message_data_push(&message->data, message->srvid, wire->data);
320 int ctdb_req_message_pull(uint8_t *buf, size_t buflen,
321 struct ctdb_req_header *h,
323 struct ctdb_req_message *c)
325 struct ctdb_req_message_wire *wire =
326 (struct ctdb_req_message_wire *)buf;
330 length = offsetof(struct ctdb_req_message_wire, data);
331 if (buflen < length) {
334 if (wire->datalen > buflen) {
337 if (length + wire->datalen < length) {
340 if (buflen < length + wire->datalen) {
345 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
351 c->srvid = wire->srvid;
352 ret = ctdb_message_data_pull(wire->data, wire->datalen, wire->srvid,
357 size_t ctdb_req_message_data_len(struct ctdb_req_header *h,
358 struct ctdb_req_message_data *c)
360 return offsetof(struct ctdb_req_message_wire, data) +
361 ctdb_tdb_data_len(&c->data);
364 int ctdb_req_message_data_push(struct ctdb_req_header *h,
365 struct ctdb_req_message_data *message,
366 uint8_t *buf, size_t *buflen)
368 struct ctdb_req_message_wire *wire =
369 (struct ctdb_req_message_wire *)buf;
372 length = ctdb_req_message_data_len(h, message);
373 if (*buflen < length) {
379 ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
381 wire->srvid = message->srvid;
382 wire->datalen = ctdb_tdb_data_len(&message->data);
383 ctdb_tdb_data_push(&message->data, wire->data, &np);
388 int ctdb_req_message_data_pull(uint8_t *buf, size_t buflen,
389 struct ctdb_req_header *h,
391 struct ctdb_req_message_data *c)
393 struct ctdb_req_message_wire *wire =
394 (struct ctdb_req_message_wire *)buf;
398 length = offsetof(struct ctdb_req_message_wire, data);
399 if (buflen < length) {
402 if (wire->datalen > buflen) {
405 if (length + wire->datalen < length) {
408 if (buflen < length + wire->datalen) {
413 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
419 c->srvid = wire->srvid;
421 ret = ctdb_tdb_data_pull(wire->data, wire->datalen,
422 mem_ctx, &c->data, &np);