ctdb-protocol: Fix marshalling for ctdb_tunable_list
[vlendec/samba-autobuild/.git] / ctdb / tests / src / protocol_types_compat_test.c
1 /*
2    protocol types backward compatibility test
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/filesys.h"
22
23 #include <assert.h>
24
25 #include "protocol/protocol_basic.c"
26 #include "protocol/protocol_types.c"
27
28 #include "tests/src/protocol_common.h"
29
30 #define COMPAT_TEST_FUNC(NAME)          test_ ##NAME## _compat
31 #define OLD_LEN_FUNC(NAME)              NAME## _len_old
32 #define OLD_PUSH_FUNC(NAME)             NAME## _push_old
33 #define OLD_PULL_FUNC(NAME)             NAME## _pull_old
34
35 #define COMPAT_TYPE1_TEST(TYPE, NAME)   \
36 static void COMPAT_TEST_FUNC(NAME)(void) \
37 { \
38         TALLOC_CTX *mem_ctx; \
39         uint8_t *buf1, *buf2; \
40         TYPE p = { 0 }, p1, p2; \
41         size_t buflen1, buflen2, np = 0; \
42         int ret; \
43 \
44         mem_ctx = talloc_new(NULL); \
45         assert(mem_ctx != NULL); \
46         FILL_FUNC(NAME)(&p); \
47         buflen1 = LEN_FUNC(NAME)(&p); \
48         buflen2 = OLD_LEN_FUNC(NAME)(&p); \
49         assert(buflen1 == buflen2); \
50         buf1 = talloc_zero_size(mem_ctx, buflen1); \
51         assert(buf1 != NULL); \
52         buf2 = talloc_zero_size(mem_ctx, buflen2); \
53         assert(buf2 != NULL); \
54         PUSH_FUNC(NAME)(&p, buf1, &np); \
55         OLD_PUSH_FUNC(NAME)(&p, buf2); \
56         assert(memcmp(buf1, buf2, buflen1) == 0); \
57         ret = PULL_FUNC(NAME)(buf1, buflen1, &p1, &np); \
58         assert(ret == 0); \
59         ret = OLD_PULL_FUNC(NAME)(buf2, buflen2, &p2); \
60         VERIFY_FUNC(NAME)(&p1, &p2); \
61         talloc_free(mem_ctx); \
62 }
63
64 #define COMPAT_TYPE3_TEST(TYPE, NAME)   \
65 static void COMPAT_TEST_FUNC(NAME)(void) \
66 { \
67         TALLOC_CTX *mem_ctx; \
68         uint8_t *buf1, *buf2; \
69         TYPE *p, *p1, *p2; \
70         size_t buflen1, buflen2, np = 0; \
71         int ret; \
72 \
73         mem_ctx = talloc_new(NULL); \
74         assert(mem_ctx != NULL); \
75         p = talloc_zero(mem_ctx, TYPE); \
76         assert(p != NULL); \
77         FILL_FUNC(NAME)(p, p); \
78         buflen1 = LEN_FUNC(NAME)(p); \
79         buflen2 = OLD_LEN_FUNC(NAME)(p); \
80         assert(buflen1 == buflen2); \
81         buf1 = talloc_zero_size(mem_ctx, buflen1); \
82         assert(buf1 != NULL); \
83         buf2 = talloc_zero_size(mem_ctx, buflen2); \
84         assert(buf2 != NULL); \
85         PUSH_FUNC(NAME)(p, buf1, &np); \
86         OLD_PUSH_FUNC(NAME)(p, buf2); \
87         assert(memcmp(buf1, buf2, buflen1) == 0); \
88         ret = PULL_FUNC(NAME)(buf1, buflen1, mem_ctx, &p1, &np); \
89         assert(ret == 0); \
90         ret = OLD_PULL_FUNC(NAME)(buf2, buflen2, mem_ctx, &p2); \
91         VERIFY_FUNC(NAME)(p1, p2); \
92         talloc_free(mem_ctx); \
93 }
94
95
96 static size_t ctdb_statistics_len_old(struct ctdb_statistics *in)
97 {
98         return sizeof(struct ctdb_statistics);
99 }
100
101 static void ctdb_statistics_push_old(struct ctdb_statistics *in, uint8_t *buf)
102 {
103         memcpy(buf, in, sizeof(struct ctdb_statistics));
104 }
105
106 static int ctdb_statistics_pull_old(uint8_t *buf, size_t buflen,
107                                     TALLOC_CTX *mem_ctx,
108                                     struct ctdb_statistics **out)
109 {
110         struct ctdb_statistics *val;
111
112         if (buflen < sizeof(struct ctdb_statistics)) {
113                 return EMSGSIZE;
114         }
115
116         val = talloc(mem_ctx, struct ctdb_statistics);
117         if (val == NULL) {
118                 return ENOMEM;
119         }
120
121         memcpy(val, buf, sizeof(struct ctdb_statistics));
122
123         *out = val;
124         return 0;
125 }
126
127 struct ctdb_vnn_map_wire {
128         uint32_t generation;
129         uint32_t size;
130         uint32_t map[1];
131 };
132
133 static size_t ctdb_vnn_map_len_old(struct ctdb_vnn_map *in)
134 {
135         return offsetof(struct ctdb_vnn_map, map) +
136                in->size * sizeof(uint32_t);
137 }
138
139 static void ctdb_vnn_map_push_old(struct ctdb_vnn_map *in, uint8_t *buf)
140 {
141         struct ctdb_vnn_map_wire *wire = (struct ctdb_vnn_map_wire *)buf;
142
143         memcpy(wire, in, offsetof(struct ctdb_vnn_map, map));
144         memcpy(wire->map, in->map, in->size * sizeof(uint32_t));
145 }
146
147 static int ctdb_vnn_map_pull_old(uint8_t *buf, size_t buflen,
148                                  TALLOC_CTX *mem_ctx,
149                                  struct ctdb_vnn_map **out)
150 {
151         struct ctdb_vnn_map *val;
152         struct ctdb_vnn_map_wire *wire = (struct ctdb_vnn_map_wire *)buf;
153
154         if (buflen < offsetof(struct ctdb_vnn_map_wire, map)) {
155                 return EMSGSIZE;
156         }
157         if (wire->size > buflen / sizeof(uint32_t)) {
158                 return EMSGSIZE;
159         }
160         if (offsetof(struct ctdb_vnn_map_wire, map) +
161             wire->size * sizeof(uint32_t) <
162             offsetof(struct ctdb_vnn_map_wire, map)) {
163                     return EMSGSIZE;
164         }
165         if (buflen < offsetof(struct ctdb_vnn_map_wire, map) +
166                      wire->size * sizeof(uint32_t)) {
167                 return EMSGSIZE;
168         }
169
170         val = talloc(mem_ctx, struct ctdb_vnn_map);
171         if (val == NULL) {
172                 return ENOMEM;
173         }
174
175         memcpy(val, wire, offsetof(struct ctdb_vnn_map, map));
176
177         val->map = talloc_memdup(val, wire->map,
178                                  wire->size * sizeof(uint32_t));
179         if (val->map == NULL) {
180                 talloc_free(val);
181                 return ENOMEM;
182         }
183
184         *out = val;
185         return 0;
186 }
187
188 struct ctdb_dbid_map_wire {
189         uint32_t num;
190         struct ctdb_dbid dbs[1];
191 };
192
193 static size_t ctdb_dbid_map_len_old(struct ctdb_dbid_map *in)
194 {
195         return sizeof(uint32_t) + in->num * sizeof(struct ctdb_dbid);
196 }
197
198 static void ctdb_dbid_map_push_old(struct ctdb_dbid_map *in, uint8_t *buf)
199 {
200         struct ctdb_dbid_map_wire *wire = (struct ctdb_dbid_map_wire *)buf;
201
202         wire->num = in->num;
203         memcpy(wire->dbs, in->dbs, in->num * sizeof(struct ctdb_dbid));
204 }
205
206 static int ctdb_dbid_map_pull_old(uint8_t *buf, size_t buflen,
207                                   TALLOC_CTX *mem_ctx,
208                                   struct ctdb_dbid_map **out)
209 {
210         struct ctdb_dbid_map *val;
211         struct ctdb_dbid_map_wire *wire = (struct ctdb_dbid_map_wire *)buf;
212
213         if (buflen < sizeof(uint32_t)) {
214                 return EMSGSIZE;
215         }
216         if (wire->num > buflen / sizeof(struct ctdb_dbid)) {
217                 return EMSGSIZE;
218         }
219         if (sizeof(uint32_t) + wire->num * sizeof(struct ctdb_dbid) <
220             sizeof(uint32_t)) {
221                 return EMSGSIZE;
222         }
223         if (buflen < sizeof(uint32_t) + wire->num * sizeof(struct ctdb_dbid)) {
224                 return EMSGSIZE;
225         }
226
227         val = talloc(mem_ctx, struct ctdb_dbid_map);
228         if (val == NULL) {
229                 return ENOMEM;
230         }
231
232         val->num = wire->num;
233
234         val->dbs = talloc_memdup(val, wire->dbs,
235                                  wire->num * sizeof(struct ctdb_dbid));
236         if (val->dbs == NULL) {
237                 talloc_free(val);
238                 return ENOMEM;
239         }
240
241         *out = val;
242         return 0;
243 }
244
245 static size_t ctdb_pulldb_len_old(struct ctdb_pulldb *in)
246 {
247         return sizeof(struct ctdb_pulldb);
248 }
249
250 static void ctdb_pulldb_push_old(struct ctdb_pulldb *in, uint8_t *buf)
251 {
252         memcpy(buf, in, sizeof(struct ctdb_pulldb));
253 }
254
255 static int ctdb_pulldb_pull_old(uint8_t *buf, size_t buflen,
256                                 TALLOC_CTX *mem_ctx, struct ctdb_pulldb **out)
257 {
258         struct ctdb_pulldb *val;
259
260         if (buflen < sizeof(struct ctdb_pulldb)) {
261                 return EMSGSIZE;
262         }
263
264         val = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_pulldb));
265         if (val == NULL) {
266                 return ENOMEM;
267         }
268
269         *out = val;
270         return 0;
271 }
272
273 static size_t ctdb_pulldb_ext_len_old(struct ctdb_pulldb_ext *in)
274 {
275         return sizeof(struct ctdb_pulldb_ext);
276 }
277
278 static void ctdb_pulldb_ext_push_old(struct ctdb_pulldb_ext *in, uint8_t *buf)
279 {
280         memcpy(buf, in, sizeof(struct ctdb_pulldb_ext));
281 }
282
283 static int ctdb_pulldb_ext_pull_old(uint8_t *buf, size_t buflen,
284                                     TALLOC_CTX *mem_ctx,
285                                     struct ctdb_pulldb_ext **out)
286 {
287         struct ctdb_pulldb_ext *val;
288
289         if (buflen < sizeof(struct ctdb_pulldb_ext)) {
290                 return EMSGSIZE;
291         }
292
293         val = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_pulldb_ext));
294         if (val == NULL) {
295                 return ENOMEM;
296         }
297
298         *out = val;
299         return 0;
300 }
301
302 static size_t ctdb_ltdb_header_len_old(struct ctdb_ltdb_header *in)
303 {
304         return sizeof(struct ctdb_ltdb_header);
305 }
306
307 static void ctdb_ltdb_header_push_old(struct ctdb_ltdb_header *in,
308                                       uint8_t *buf)
309 {
310         memcpy(buf, in, sizeof(struct ctdb_ltdb_header));
311 }
312
313 static int ctdb_ltdb_header_pull_old(uint8_t *buf, size_t buflen,
314                                      struct ctdb_ltdb_header *out)
315 {
316         if (buflen < sizeof(struct ctdb_ltdb_header)) {
317                 return EMSGSIZE;
318         }
319
320         memcpy(out, buf, sizeof(struct ctdb_ltdb_header));
321         return 0;
322 }
323
324 struct ctdb_rec_data_wire {
325         uint32_t length;
326         uint32_t reqid;
327         uint32_t keylen;
328         uint32_t datalen;
329         uint8_t data[1];
330 };
331
332 static size_t ctdb_rec_data_len_old(struct ctdb_rec_data *in)
333 {
334         return offsetof(struct ctdb_rec_data_wire, data) +
335                in->key.dsize + in->data.dsize +
336                (in->header == NULL ? 0 : sizeof(struct ctdb_ltdb_header));
337 }
338
339 static void ctdb_rec_data_push_old(struct ctdb_rec_data *in, uint8_t *buf)
340 {
341         struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
342         size_t offset;
343
344         wire->length = ctdb_rec_data_len(in);
345         wire->reqid = in->reqid;
346         wire->keylen = in->key.dsize;
347         wire->datalen = in->data.dsize;
348         if (in->header != NULL) {
349                 wire->datalen += sizeof(struct ctdb_ltdb_header);
350         }
351
352         memcpy(wire->data, in->key.dptr, in->key.dsize);
353         offset = in->key.dsize;
354         if (in->header != NULL) {
355                 memcpy(&wire->data[offset], in->header,
356                        sizeof(struct ctdb_ltdb_header));
357                 offset += sizeof(struct ctdb_ltdb_header);
358         }
359         if (in->data.dsize > 0) {
360                 memcpy(&wire->data[offset], in->data.dptr, in->data.dsize);
361         }
362 }
363
364 static int ctdb_rec_data_pull_data_old(uint8_t *buf, size_t buflen,
365                                        uint32_t *reqid,
366                                        struct ctdb_ltdb_header **header,
367                                        TDB_DATA *key, TDB_DATA *data,
368                                        size_t *reclen)
369 {
370         struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
371         size_t offset;
372
373         if (buflen < offsetof(struct ctdb_rec_data_wire, data)) {
374                 return EMSGSIZE;
375         }
376         if (wire->keylen > buflen || wire->datalen > buflen) {
377                 return EMSGSIZE;
378         }
379         if (offsetof(struct ctdb_rec_data_wire, data) + wire->keylen <
380             offsetof(struct ctdb_rec_data_wire, data)) {
381                 return EMSGSIZE;
382         }
383         if (offsetof(struct ctdb_rec_data_wire, data) +
384                 wire->keylen + wire->datalen <
385             offsetof(struct ctdb_rec_data_wire, data)) {
386                 return EMSGSIZE;
387         }
388         if (buflen < offsetof(struct ctdb_rec_data_wire, data) +
389                         wire->keylen + wire->datalen) {
390                 return EMSGSIZE;
391         }
392
393         *reqid = wire->reqid;
394
395         key->dsize = wire->keylen;
396         key->dptr = wire->data;
397         offset = wire->keylen;
398
399         /* Always set header to NULL.  If it is required, exact it using
400          * ctdb_rec_data_extract_header()
401          */
402         *header = NULL;
403
404         data->dsize = wire->datalen;
405         data->dptr = &wire->data[offset];
406
407         *reclen = offsetof(struct ctdb_rec_data_wire, data) +
408                         wire->keylen + wire->datalen;
409
410         return 0;
411 }
412
413 static int ctdb_rec_data_pull_elems_old(uint8_t *buf, size_t buflen,
414                                         TALLOC_CTX *mem_ctx,
415                                         struct ctdb_rec_data *out)
416 {
417         uint32_t reqid;
418         struct ctdb_ltdb_header *header;
419         TDB_DATA key, data;
420         size_t reclen;
421         int ret;
422
423         ret = ctdb_rec_data_pull_data_old(buf, buflen, &reqid, &header,
424                                           &key, &data, &reclen);
425         if (ret != 0) {
426                 return ret;
427         }
428
429         out->reqid = reqid;
430         out->header = NULL;
431
432         out->key.dsize = key.dsize;
433         if (key.dsize > 0) {
434                 out->key.dptr = talloc_memdup(mem_ctx, key.dptr, key.dsize);
435                 if (out->key.dptr == NULL) {
436                         return ENOMEM;
437                 }
438         }
439
440         out->data.dsize = data.dsize;
441         if (data.dsize > 0) {
442                 out->data.dptr = talloc_memdup(mem_ctx, data.dptr, data.dsize);
443                 if (out->data.dptr == NULL) {
444                         return ENOMEM;
445                 }
446         }
447
448         return 0;
449 }
450
451 static int ctdb_rec_data_pull_old(uint8_t *buf, size_t buflen,
452                                   TALLOC_CTX *mem_ctx,
453                                   struct ctdb_rec_data **out)
454 {
455         struct ctdb_rec_data *val;
456         int ret;
457
458         val = talloc(mem_ctx, struct ctdb_rec_data);
459         if (val == NULL) {
460                 return ENOMEM;
461         }
462
463         ret = ctdb_rec_data_pull_elems_old(buf, buflen, val, val);
464         if (ret != 0) {
465                 TALLOC_FREE(val);
466                 return ret;
467         }
468
469         *out = val;
470         return ret;
471 }
472
473 struct ctdb_rec_buffer_wire {
474         uint32_t db_id;
475         uint32_t count;
476         uint8_t data[1];
477 };
478
479 static size_t ctdb_rec_buffer_len_old(struct ctdb_rec_buffer *in)
480 {
481         return offsetof(struct ctdb_rec_buffer_wire, data) + in->buflen;
482 }
483
484 static void ctdb_rec_buffer_push_old(struct ctdb_rec_buffer *in, uint8_t *buf)
485 {
486         struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
487
488         wire->db_id = in->db_id;
489         wire->count = in->count;
490         if (in->buflen > 0) {
491                 memcpy(wire->data, in->buf, in->buflen);
492         }
493 }
494
495 static int ctdb_rec_buffer_pull_old(uint8_t *buf, size_t buflen,
496                                     TALLOC_CTX *mem_ctx,
497                                     struct ctdb_rec_buffer **out)
498 {
499         struct ctdb_rec_buffer *val;
500         struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
501         size_t offset;
502
503         if (buflen < offsetof(struct ctdb_rec_buffer_wire, data)) {
504                 return EMSGSIZE;
505         }
506
507         val = talloc(mem_ctx, struct ctdb_rec_buffer);
508         if (val == NULL) {
509                 return ENOMEM;
510         }
511
512         val->db_id = wire->db_id;
513         val->count = wire->count;
514
515         offset = offsetof(struct ctdb_rec_buffer_wire, data);
516         val->buflen = buflen - offset;
517         val->buf = talloc_memdup(val, wire->data, val->buflen);
518         if (val->buf == NULL) {
519                 talloc_free(val);
520                 return ENOMEM;
521         }
522
523         *out = val;
524         return 0;
525 }
526
527 static size_t ctdb_traverse_start_len_old(struct ctdb_traverse_start *in)
528 {
529         return sizeof(struct ctdb_traverse_start);
530 }
531
532 static void ctdb_traverse_start_push_old(struct ctdb_traverse_start *in,
533                                          uint8_t *buf)
534 {
535         memcpy(buf, in, sizeof(struct ctdb_traverse_start));
536 }
537
538 static int ctdb_traverse_start_pull_old(uint8_t *buf, size_t buflen,
539                                         TALLOC_CTX *mem_ctx,
540                                         struct ctdb_traverse_start **out)
541 {
542         struct ctdb_traverse_start *val;
543
544         if (buflen < sizeof(struct ctdb_traverse_start)) {
545                 return EMSGSIZE;
546         }
547
548         val = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_traverse_start));
549         if (val == NULL) {
550                 return ENOMEM;
551         }
552
553         *out = val;
554         return 0;
555 }
556
557 static size_t ctdb_traverse_all_len_old(struct ctdb_traverse_all *in)
558 {
559         return sizeof(struct ctdb_traverse_all);
560 }
561
562 static void ctdb_traverse_all_push_old(struct ctdb_traverse_all *in,
563                                        uint8_t *buf)
564 {
565         memcpy(buf, in, sizeof(struct ctdb_traverse_all));
566 }
567
568 static int ctdb_traverse_all_pull_old(uint8_t *buf, size_t buflen,
569                                       TALLOC_CTX *mem_ctx,
570                                       struct ctdb_traverse_all **out)
571 {
572         struct ctdb_traverse_all *val;
573
574         if (buflen < sizeof(struct ctdb_traverse_all)) {
575                 return EMSGSIZE;
576         }
577
578         val = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_traverse_all));
579         if (val == NULL) {
580                 return ENOMEM;
581         }
582
583         *out = val;
584         return 0;
585 }
586
587 static size_t ctdb_traverse_start_ext_len_old(
588                         struct ctdb_traverse_start_ext *in)
589 {
590         return sizeof(struct ctdb_traverse_start_ext);
591 }
592
593 static void ctdb_traverse_start_ext_push_old(
594                         struct ctdb_traverse_start_ext *in, uint8_t *buf)
595 {
596         memcpy(buf, in, sizeof(struct ctdb_traverse_start_ext));
597 }
598
599 static int ctdb_traverse_start_ext_pull_old(uint8_t *buf, size_t buflen,
600                                             TALLOC_CTX *mem_ctx,
601                                             struct ctdb_traverse_start_ext **out)
602 {
603         struct ctdb_traverse_start_ext *val;
604
605         if (buflen < sizeof(struct ctdb_traverse_start_ext)) {
606                 return EMSGSIZE;
607         }
608
609         val = talloc_memdup(mem_ctx, buf,
610                             sizeof(struct ctdb_traverse_start_ext));
611         if (val == NULL) {
612                 return ENOMEM;
613         }
614
615         *out = val;
616         return 0;
617 }
618
619 static size_t ctdb_traverse_all_ext_len_old(struct ctdb_traverse_all_ext *in)
620 {
621         return sizeof(struct ctdb_traverse_all_ext);
622 }
623
624 static void ctdb_traverse_all_ext_push_old(struct ctdb_traverse_all_ext *in,
625                                            uint8_t *buf)
626 {
627         memcpy(buf, in, sizeof(struct ctdb_traverse_all_ext));
628 }
629
630 static int ctdb_traverse_all_ext_pull_old(uint8_t *buf, size_t buflen,
631                                           TALLOC_CTX *mem_ctx,
632                                           struct ctdb_traverse_all_ext **out)
633 {
634         struct ctdb_traverse_all_ext *val;
635
636         if (buflen < sizeof(struct ctdb_traverse_all_ext)) {
637                 return EMSGSIZE;
638         }
639
640         val = talloc_memdup(mem_ctx, buf,
641                             sizeof(struct ctdb_traverse_all_ext));
642         if (val == NULL) {
643                 return ENOMEM;
644         }
645
646         *out = val;
647         return 0;
648 }
649
650 static size_t ctdb_sock_addr_len_old(ctdb_sock_addr *in)
651 {
652         return sizeof(ctdb_sock_addr);
653 }
654
655 static void ctdb_sock_addr_push_old(ctdb_sock_addr *in, uint8_t *buf)
656 {
657         memcpy(buf, in, sizeof(ctdb_sock_addr));
658 }
659
660 static int ctdb_sock_addr_pull_elems_old(uint8_t *buf, size_t buflen,
661                                          TALLOC_CTX *mem_ctx,
662                                          ctdb_sock_addr *out)
663 {
664         if (buflen < sizeof(ctdb_sock_addr)) {
665                 return EMSGSIZE;
666         }
667
668         memcpy(out, buf, sizeof(ctdb_sock_addr));
669
670         return 0;
671 }
672
673 static int ctdb_sock_addr_pull_old(uint8_t *buf, size_t buflen,
674                                    TALLOC_CTX *mem_ctx, ctdb_sock_addr **out)
675 {
676         ctdb_sock_addr *val;
677         int ret;
678
679         val = talloc(mem_ctx, ctdb_sock_addr);
680         if (val == NULL) {
681                 return ENOMEM;
682         }
683
684         ret = ctdb_sock_addr_pull_elems_old(buf, buflen, val, val);
685         if (ret != 0) {
686                 TALLOC_FREE(val);
687                 return ret;
688         }
689
690         *out = val;
691         return ret;
692 }
693
694 static size_t ctdb_connection_len_old(struct ctdb_connection *in)
695 {
696         return sizeof(struct ctdb_connection);
697 }
698
699 static void ctdb_connection_push_old(struct ctdb_connection *in, uint8_t *buf)
700 {
701         memcpy(buf, in, sizeof(struct ctdb_connection));
702 }
703
704 static int ctdb_connection_pull_elems_old(uint8_t *buf, size_t buflen,
705                                           TALLOC_CTX *mem_ctx,
706                                           struct ctdb_connection *out)
707 {
708         if (buflen < sizeof(struct ctdb_connection)) {
709                 return EMSGSIZE;
710         }
711
712         memcpy(out, buf, sizeof(struct ctdb_connection));
713
714         return 0;
715 }
716
717 static int ctdb_connection_pull_old(uint8_t *buf, size_t buflen,
718                                     TALLOC_CTX *mem_ctx,
719                                     struct ctdb_connection **out)
720 {
721         struct ctdb_connection *val;
722         int ret;
723
724         val = talloc(mem_ctx, struct ctdb_connection);
725         if (val == NULL) {
726                 return ENOMEM;
727         }
728
729         ret = ctdb_connection_pull_elems_old(buf, buflen, val, val);
730         if (ret != 0) {
731                 TALLOC_FREE(val);
732                 return ret;
733         }
734
735         *out = val;
736         return ret;
737 }
738
739 struct ctdb_tunable_wire {
740         uint32_t value;
741         uint32_t length;
742         uint8_t name[1];
743 };
744
745 static size_t ctdb_tunable_len_old(struct ctdb_tunable *in)
746 {
747         return offsetof(struct ctdb_tunable_wire, name) +
748                strlen(in->name) + 1;
749 }
750
751 static void ctdb_tunable_push_old(struct ctdb_tunable *in, uint8_t *buf)
752 {
753         struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
754
755         wire->value = in->value;
756         wire->length = strlen(in->name) + 1;
757         memcpy(wire->name, in->name, wire->length);
758 }
759
760 static int ctdb_tunable_pull_old(uint8_t *buf, size_t buflen,
761                                  TALLOC_CTX *mem_ctx,
762                                  struct ctdb_tunable **out)
763 {
764         struct ctdb_tunable *val;
765         struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
766
767         if (buflen < offsetof(struct ctdb_tunable_wire, name)) {
768                 return EMSGSIZE;
769         }
770         if (wire->length > buflen) {
771                 return EMSGSIZE;
772         }
773         if (offsetof(struct ctdb_tunable_wire, name) + wire->length <
774             offsetof(struct ctdb_tunable_wire, name)) {
775                 return EMSGSIZE;
776         }
777         if (buflen < offsetof(struct ctdb_tunable_wire, name) + wire->length) {
778                 return EMSGSIZE;
779         }
780
781         val = talloc(mem_ctx, struct ctdb_tunable);
782         if (val == NULL) {
783                 return ENOMEM;
784         }
785
786         val->value = wire->value;
787         val->name = talloc_memdup(val, wire->name, wire->length);
788         if (val->name == NULL) {
789                 talloc_free(val);
790                 return ENOMEM;
791         }
792
793         *out = val;
794         return 0;
795 }
796
797 static size_t ctdb_node_flag_change_len_old(struct ctdb_node_flag_change *in)
798 {
799         return sizeof(struct ctdb_node_flag_change);
800 }
801
802 static void ctdb_node_flag_change_push_old(struct ctdb_node_flag_change *in,
803                                            uint8_t *buf)
804 {
805         memcpy(buf, in, sizeof(struct ctdb_node_flag_change));
806 }
807
808 static int ctdb_node_flag_change_pull_old(uint8_t *buf, size_t buflen,
809                                           TALLOC_CTX *mem_ctx,
810                                           struct ctdb_node_flag_change **out)
811 {
812         struct ctdb_node_flag_change *val;
813
814         if (buflen < sizeof(struct ctdb_node_flag_change)) {
815                 return EMSGSIZE;
816         }
817
818         val = talloc_memdup(mem_ctx, buf,
819                             sizeof(struct ctdb_node_flag_change));
820         if (val == NULL) {
821                 return ENOMEM;
822         }
823
824         *out = val;
825         return 0;
826 }
827
828 struct ctdb_var_list_wire {
829         uint32_t length;
830         char list_str[1];
831 };
832
833 static size_t ctdb_var_list_len_old(struct ctdb_var_list *in)
834 {
835         int i;
836         size_t len = sizeof(uint32_t);
837
838         for (i=0; i<in->count; i++) {
839                 len += strlen(in->var[i]) + 1;
840         }
841         return len;
842 }
843
844 static void ctdb_var_list_push_old(struct ctdb_var_list *in, uint8_t *buf)
845 {
846         struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
847         int i, n;
848         size_t offset = 0;
849
850         if (in->count > 0) {
851                 n = sprintf(wire->list_str, "%s", in->var[0]);
852                 offset += n;
853         }
854         for (i=1; i<in->count; i++) {
855                 n = sprintf(&wire->list_str[offset], ":%s", in->var[i]);
856                 offset += n;
857         }
858         wire->length = offset + 1;
859 }
860
861 static int ctdb_var_list_pull_old(uint8_t *buf, size_t buflen,
862                                   TALLOC_CTX *mem_ctx,
863                                   struct ctdb_var_list **out)
864 {
865         struct ctdb_var_list *val = NULL;
866         struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
867         char *str, *s, *tok, *ptr;
868         const char **list;
869
870         if (buflen < sizeof(uint32_t)) {
871                 return EMSGSIZE;
872         }
873         if (wire->length > buflen) {
874                 return EMSGSIZE;
875         }
876         if (sizeof(uint32_t) + wire->length < sizeof(uint32_t)) {
877                 return EMSGSIZE;
878         }
879         if (buflen < sizeof(uint32_t) + wire->length) {
880                 return EMSGSIZE;
881         }
882
883         str = talloc_strndup(mem_ctx, (char *)wire->list_str, wire->length);
884         if (str == NULL) {
885                 return ENOMEM;
886         }
887
888         val = talloc_zero(mem_ctx, struct ctdb_var_list);
889         if (val == NULL) {
890                 goto fail;
891         }
892
893         s = str;
894         while ((tok = strtok_r(s, ":", &ptr)) != NULL) {
895                 s = NULL;
896                 list = talloc_realloc(val, val->var, const char *,
897                                       val->count+1);
898                 if (list == NULL) {
899                         goto fail;
900                 }
901
902                 val->var = list;
903                 val->var[val->count] = talloc_strdup(val, tok);
904                 if (val->var[val->count] == NULL) {
905                         goto fail;
906                 }
907                 val->count++;
908         }
909
910         talloc_free(str);
911         *out = val;
912         return 0;
913
914 fail:
915         talloc_free(str);
916         talloc_free(val);
917         return ENOMEM;
918 }
919
920 static size_t ctdb_tunable_list_len_old(struct ctdb_tunable_list *in)
921 {
922         return sizeof(struct ctdb_tunable_list);
923 }
924
925 static void ctdb_tunable_list_push_old(struct ctdb_tunable_list *in,
926                                        uint8_t *buf)
927 {
928         memcpy(buf, in, sizeof(struct ctdb_tunable_list));
929 }
930
931 static int ctdb_tunable_list_pull_old(uint8_t *buf, size_t buflen,
932                                       TALLOC_CTX *mem_ctx,
933                                       struct ctdb_tunable_list **out)
934 {
935         struct ctdb_tunable_list *val;
936
937         if (buflen < sizeof(struct ctdb_tunable_list)) {
938                 return EMSGSIZE;
939         }
940
941         val = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_tunable_list));
942         if (val == NULL) {
943                 return ENOMEM;
944         }
945
946         *out = val;
947         return 0;
948 }
949
950
951 COMPAT_TYPE3_TEST(struct ctdb_statistics, ctdb_statistics);
952 COMPAT_TYPE3_TEST(struct ctdb_vnn_map, ctdb_vnn_map);
953 COMPAT_TYPE3_TEST(struct ctdb_dbid_map, ctdb_dbid_map);
954 COMPAT_TYPE3_TEST(struct ctdb_pulldb, ctdb_pulldb);
955 COMPAT_TYPE3_TEST(struct ctdb_pulldb_ext, ctdb_pulldb_ext);
956
957 COMPAT_TYPE1_TEST(struct ctdb_ltdb_header, ctdb_ltdb_header);
958
959 COMPAT_TYPE3_TEST(struct ctdb_rec_data, ctdb_rec_data);
960 COMPAT_TYPE3_TEST(struct ctdb_rec_buffer, ctdb_rec_buffer);
961 COMPAT_TYPE3_TEST(struct ctdb_traverse_start, ctdb_traverse_start);
962 COMPAT_TYPE3_TEST(struct ctdb_traverse_all, ctdb_traverse_all);
963 COMPAT_TYPE3_TEST(struct ctdb_traverse_start_ext, ctdb_traverse_start_ext);
964 COMPAT_TYPE3_TEST(struct ctdb_traverse_all_ext, ctdb_traverse_all_ext);
965 COMPAT_TYPE3_TEST(ctdb_sock_addr, ctdb_sock_addr);
966 COMPAT_TYPE3_TEST(struct ctdb_connection, ctdb_connection);
967 COMPAT_TYPE3_TEST(struct ctdb_tunable, ctdb_tunable);
968 COMPAT_TYPE3_TEST(struct ctdb_node_flag_change, ctdb_node_flag_change);
969 COMPAT_TYPE3_TEST(struct ctdb_var_list, ctdb_var_list);
970 COMPAT_TYPE3_TEST(struct ctdb_tunable_list, ctdb_tunable_list);
971
972 int main(int argc, char *argv[])
973 {
974         if (argc == 2) {
975                 int seed = atoi(argv[1]);
976                 srandom(seed);
977         }
978
979         COMPAT_TEST_FUNC(ctdb_statistics)();
980         COMPAT_TEST_FUNC(ctdb_vnn_map)();
981         COMPAT_TEST_FUNC(ctdb_dbid_map)();
982         COMPAT_TEST_FUNC(ctdb_pulldb)();
983         COMPAT_TEST_FUNC(ctdb_pulldb_ext)();
984         COMPAT_TEST_FUNC(ctdb_ltdb_header)();
985         COMPAT_TEST_FUNC(ctdb_rec_data)();
986         COMPAT_TEST_FUNC(ctdb_rec_buffer)();
987         COMPAT_TEST_FUNC(ctdb_traverse_start)();
988         COMPAT_TEST_FUNC(ctdb_traverse_all)();
989         COMPAT_TEST_FUNC(ctdb_traverse_start_ext)();
990         COMPAT_TEST_FUNC(ctdb_traverse_all_ext)();
991         COMPAT_TEST_FUNC(ctdb_sock_addr)();
992         COMPAT_TEST_FUNC(ctdb_connection)();
993         COMPAT_TEST_FUNC(ctdb_tunable)();
994         COMPAT_TEST_FUNC(ctdb_node_flag_change)();
995         COMPAT_TEST_FUNC(ctdb_var_list)();
996         COMPAT_TEST_FUNC(ctdb_tunable_list)();
997
998         return 0;
999 }