source: vendor/current/ctdb/protocol/protocol_message.c

Last change on this file was 989, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.7
File size: 9.0 KB
Line 
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
30struct ctdb_req_message_wire {
31 struct ctdb_req_header hdr;
32 uint64_t srvid;
33 uint32_t datalen;
34 uint8_t data[1];
35};
36
37static size_t ctdb_message_data_len(union ctdb_message_data *mdata,
38 uint64_t srvid)
39{
40 size_t len = 0;
41
42 switch (srvid) {
43 case CTDB_SRVID_BANNING:
44 len = ctdb_uint32_len(mdata->pnn);
45 break;
46
47 case CTDB_SRVID_ELECTION:
48 len = ctdb_election_message_len(mdata->election);
49 break;
50
51 case CTDB_SRVID_RECONFIGURE:
52 break;
53
54 case CTDB_SRVID_RELEASE_IP:
55 len = ctdb_string_len(mdata->ipaddr);
56 break;
57
58 case CTDB_SRVID_TAKE_IP:
59 len = ctdb_string_len(mdata->ipaddr);
60 break;
61
62 case CTDB_SRVID_SET_NODE_FLAGS:
63 len = ctdb_node_flag_change_len(mdata->flag_change);
64 break;
65
66 case CTDB_SRVID_RECD_UPDATE_IP:
67 len = ctdb_public_ip_len(mdata->pubip);
68 break;
69
70 case CTDB_SRVID_VACUUM_FETCH:
71 len = ctdb_rec_buffer_len(mdata->recbuf);
72 break;
73
74 case CTDB_SRVID_DETACH_DATABASE:
75 len = ctdb_uint32_len(mdata->db_id);
76 break;
77
78 case CTDB_SRVID_MEM_DUMP:
79 len = ctdb_srvid_message_len(mdata->msg);
80 break;
81
82 case CTDB_SRVID_PUSH_NODE_FLAGS:
83 len = ctdb_node_flag_change_len(mdata->flag_change);
84 break;
85
86 case CTDB_SRVID_RELOAD_NODES:
87 break;
88
89 case CTDB_SRVID_TAKEOVER_RUN:
90 len = ctdb_srvid_message_len(mdata->msg);
91 break;
92
93 case CTDB_SRVID_REBALANCE_NODE:
94 len = ctdb_uint32_len(mdata->pnn);
95 break;
96
97 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
98 len = ctdb_disable_message_len(mdata->disable);
99 break;
100
101 case CTDB_SRVID_DISABLE_RECOVERIES:
102 len = ctdb_disable_message_len(mdata->disable);
103 break;
104
105 case CTDB_SRVID_DISABLE_IP_CHECK:
106 len = ctdb_uint32_len(mdata->timeout);
107 break;
108
109 default:
110 len = ctdb_tdb_data_len(mdata->data);
111 break;
112 }
113
114 return len;
115}
116
117static void ctdb_message_data_push(union ctdb_message_data *mdata,
118 uint64_t srvid, uint8_t *buf)
119{
120 switch (srvid) {
121 case CTDB_SRVID_BANNING:
122 ctdb_uint32_push(mdata->pnn, buf);
123 break;
124
125 case CTDB_SRVID_ELECTION:
126 ctdb_election_message_push(mdata->election, buf);
127 break;
128
129 case CTDB_SRVID_RECONFIGURE:
130 break;
131
132 case CTDB_SRVID_RELEASE_IP:
133 ctdb_string_push(mdata->ipaddr, buf);
134 break;
135
136 case CTDB_SRVID_TAKE_IP:
137 ctdb_string_push(mdata->ipaddr, buf);
138 break;
139
140 case CTDB_SRVID_SET_NODE_FLAGS:
141 ctdb_node_flag_change_push(mdata->flag_change, buf);
142 break;
143
144 case CTDB_SRVID_RECD_UPDATE_IP:
145 ctdb_public_ip_push(mdata->pubip, buf);
146 break;
147
148 case CTDB_SRVID_VACUUM_FETCH:
149 ctdb_rec_buffer_push(mdata->recbuf, buf);
150 break;
151
152 case CTDB_SRVID_DETACH_DATABASE:
153 ctdb_uint32_push(mdata->db_id, buf);
154 break;
155
156 case CTDB_SRVID_MEM_DUMP:
157 ctdb_srvid_message_push(mdata->msg, buf);
158 break;
159
160 case CTDB_SRVID_PUSH_NODE_FLAGS:
161 ctdb_node_flag_change_push(mdata->flag_change, buf);
162 break;
163
164 case CTDB_SRVID_RELOAD_NODES:
165 break;
166
167 case CTDB_SRVID_TAKEOVER_RUN:
168 ctdb_srvid_message_push(mdata->msg, buf);
169 break;
170
171 case CTDB_SRVID_REBALANCE_NODE:
172 ctdb_uint32_push(mdata->pnn, buf);
173 break;
174
175 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
176 ctdb_disable_message_push(mdata->disable, buf);
177 break;
178
179 case CTDB_SRVID_DISABLE_RECOVERIES:
180 ctdb_disable_message_push(mdata->disable, buf);
181 break;
182
183 case CTDB_SRVID_DISABLE_IP_CHECK:
184 ctdb_uint32_push(mdata->timeout, buf);
185 break;
186
187 default:
188 ctdb_tdb_data_push(mdata->data, buf);
189 break;
190 }
191}
192
193static int ctdb_message_data_pull(uint8_t *buf, size_t buflen,
194 uint64_t srvid, TALLOC_CTX *mem_ctx,
195 union ctdb_message_data *mdata)
196{
197 int ret = 0;
198
199 switch (srvid) {
200 case CTDB_SRVID_BANNING:
201 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
202 break;
203
204 case CTDB_SRVID_ELECTION:
205 ret = ctdb_election_message_pull(buf, buflen, mem_ctx,
206 &mdata->election);
207 break;
208
209 case CTDB_SRVID_RECONFIGURE:
210 break;
211
212 case CTDB_SRVID_RELEASE_IP:
213 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr);
214 break;
215
216 case CTDB_SRVID_TAKE_IP:
217 ret = ctdb_string_pull(buf, buflen, mem_ctx, &mdata->ipaddr);
218 break;
219
220 case CTDB_SRVID_SET_NODE_FLAGS:
221 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
222 &mdata->flag_change);
223 break;
224
225 case CTDB_SRVID_RECD_UPDATE_IP:
226 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
227 &mdata->pubip);
228 break;
229
230 case CTDB_SRVID_VACUUM_FETCH:
231 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
232 &mdata->recbuf);
233 break;
234
235 case CTDB_SRVID_DETACH_DATABASE:
236 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->db_id);
237 break;
238
239 case CTDB_SRVID_MEM_DUMP:
240 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
241 &mdata->msg);
242 break;
243
244 case CTDB_SRVID_PUSH_NODE_FLAGS:
245 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
246 &mdata->flag_change);
247 break;
248
249 case CTDB_SRVID_RELOAD_NODES:
250 break;
251
252 case CTDB_SRVID_TAKEOVER_RUN:
253 ret = ctdb_srvid_message_pull(buf, buflen, mem_ctx,
254 &mdata->msg);
255 break;
256
257 case CTDB_SRVID_REBALANCE_NODE:
258 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
259 break;
260
261 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
262 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
263 &mdata->disable);
264 break;
265
266 case CTDB_SRVID_DISABLE_RECOVERIES:
267 ret = ctdb_disable_message_pull(buf, buflen, mem_ctx,
268 &mdata->disable);
269 break;
270
271 case CTDB_SRVID_DISABLE_IP_CHECK:
272 ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->timeout);
273 break;
274
275 default:
276 ret = ctdb_tdb_data_pull(buf, buflen, mem_ctx, &mdata->data);
277 break;
278 }
279
280 return ret;
281}
282
283int ctdb_req_message_push(struct ctdb_req_header *h,
284 struct ctdb_req_message *message,
285 TALLOC_CTX *mem_ctx,
286 uint8_t **pkt, size_t *pkt_len)
287{
288 struct ctdb_req_message_wire *wire;
289 uint8_t *buf;
290 size_t length, buflen, datalen;
291 int ret;
292
293 datalen = ctdb_message_data_len(&message->data, message->srvid);
294 length = offsetof(struct ctdb_req_message_wire, data) + datalen;
295
296 ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
297 if (ret != 0) {
298 return ret;
299 }
300
301 wire = (struct ctdb_req_message_wire *)buf;
302
303 h->length = buflen;
304 memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));
305
306 wire->srvid = message->srvid;
307 wire->datalen = datalen;
308 ctdb_message_data_push(&message->data, message->srvid, wire->data);
309
310 *pkt = buf;
311 *pkt_len = buflen;
312 return 0;
313}
314
315int ctdb_req_message_pull(uint8_t *pkt, size_t pkt_len,
316 struct ctdb_req_header *h,
317 TALLOC_CTX *mem_ctx,
318 struct ctdb_req_message *message)
319{
320 struct ctdb_req_message_wire *wire =
321 (struct ctdb_req_message_wire *)pkt;
322 size_t length;
323 int ret;
324
325 length = offsetof(struct ctdb_req_message_wire, data);
326
327 if (pkt_len < length) {
328 return EMSGSIZE;
329 }
330 if (pkt_len < length + wire->datalen) {
331 return EMSGSIZE;
332 }
333
334 memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));
335
336 message->srvid = wire->srvid;
337 ret = ctdb_message_data_pull(wire->data, wire->datalen, wire->srvid,
338 mem_ctx, &message->data);
339 return ret;
340}
341
342int ctdb_req_message_data_push(struct ctdb_req_header *h,
343 struct ctdb_req_message_data *message,
344 TALLOC_CTX *mem_ctx,
345 uint8_t **pkt, size_t *pkt_len)
346{
347 struct ctdb_req_message_wire *wire;
348 uint8_t *buf;
349 size_t length, buflen;
350 int ret;
351
352 length = offsetof(struct ctdb_req_message_wire, data) +
353 message->data.dsize;
354
355 ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
356 if (ret != 0) {
357 return ret;
358 }
359
360 wire = (struct ctdb_req_message_wire *)buf;
361
362 h->length = buflen;
363 memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));
364
365 wire->srvid = message->srvid;
366 wire->datalen = message->data.dsize;
367 if (message->data.dsize > 0) {
368 memcpy(wire->data, message->data.dptr, message->data.dsize);
369 }
370
371 *pkt = buf;
372 *pkt_len = buflen;
373 return 0;
374}
375
376int ctdb_req_message_data_pull(uint8_t *pkt, size_t pkt_len,
377 struct ctdb_req_header *h,
378 TALLOC_CTX *mem_ctx,
379 struct ctdb_req_message_data *message)
380{
381 struct ctdb_req_message_wire *wire =
382 (struct ctdb_req_message_wire *)pkt;
383 size_t length;
384
385 length = offsetof(struct ctdb_req_message_wire, data);
386
387 if (pkt_len < length) {
388 return EMSGSIZE;
389 }
390 if (pkt_len < length + wire->datalen) {
391 return EMSGSIZE;
392 }
393
394 memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));
395
396 message->srvid = wire->srvid;
397 message->data.dsize = wire->datalen;
398 if (wire->datalen > 0) {
399 message->data.dptr = talloc_memdup(mem_ctx, wire->data,
400 wire->datalen);
401 if (message->data.dptr == NULL) {
402 return ENOMEM;
403 }
404 }
405
406 return 0;
407}
Note: See TracBrowser for help on using the repository browser.