Initial Implementation of the DS objects access checks.
[sfrench/samba-autobuild/.git] / source4 / lib / ldb / common / ldb_ldif.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2004
5
6      ** NOTE! The following LGPL license applies to the ldb
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9    
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 3 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 /*
25  *  Name: ldb
26  *
27  *  Component: ldif routines
28  *
29  *  Description: ldif pack/unpack routines
30  *
31  *  Author: Andrew Tridgell
32  */
33
34 /*
35   see RFC2849 for the LDIF format definition
36 */
37
38 #include "ldb_private.h"
39 #include "system/locale.h"
40
41 /*
42   
43 */
44 static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
45 {
46         struct stat statbuf;
47         char *buf;
48         int count, size, bytes;
49         int ret;
50         int f;
51         const char *fname = (const char *)value->data;
52
53         if (strncmp(fname, "file://", 7) != 0) {
54                 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
55         }
56         fname += 7;
57
58         f = open(fname, O_RDONLY);
59         if (f == -1) {
60                 return -1;
61         }
62
63         if (fstat(f, &statbuf) != 0) {
64                 ret = -1;
65                 goto done;
66         }
67
68         if (statbuf.st_size == 0) {
69                 ret = -1;
70                 goto done;
71         }
72
73         value->data = (uint8_t *)talloc_size(mem_ctx, statbuf.st_size + 1);
74         if (value->data == NULL) {
75                 ret = -1;
76                 goto done;
77         }
78         value->data[statbuf.st_size] = 0;
79
80         count = 0;
81         size = statbuf.st_size;
82         buf = (char *)value->data;
83         while (count < statbuf.st_size) {
84                 bytes = read(f, buf, size);
85                 if (bytes == -1) {
86                         talloc_free(value->data);
87                         ret = -1;
88                         goto done;
89                 }
90                 count += bytes;
91                 buf += bytes;
92                 size -= bytes;
93         }
94
95         value->length = statbuf.st_size;
96         ret = statbuf.st_size;
97
98 done:
99         close(f);
100         return ret;
101 }
102
103 /*
104   this base64 decoder was taken from jitterbug (written by tridge).
105   we might need to replace it with a new version
106 */
107 int ldb_base64_decode(char *s)
108 {
109         const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
110         int bit_offset=0, byte_offset, idx, i, n;
111         uint8_t *d = (uint8_t *)s;
112         char *p=NULL;
113
114         n=i=0;
115
116         while (*s && (p=strchr(b64,*s))) {
117                 idx = (int)(p - b64);
118                 byte_offset = (i*6)/8;
119                 bit_offset = (i*6)%8;
120                 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
121                 if (bit_offset < 3) {
122                         d[byte_offset] |= (idx << (2-bit_offset));
123                         n = byte_offset+1;
124                 } else {
125                         d[byte_offset] |= (idx >> (bit_offset-2));
126                         d[byte_offset+1] = 0;
127                         d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
128                         n = byte_offset+2;
129                 }
130                 s++; i++;
131         }
132         if (bit_offset >= 3) {
133                 n--;
134         }
135
136         if (*s && !p) {
137                 /* the only termination allowed */
138                 if (*s != '=') {
139                         return -1;
140                 }
141         }
142
143         /* null terminate */
144         d[n] = 0;
145         return n;
146 }
147
148
149 /*
150   encode as base64
151   caller frees
152 */
153 char *ldb_base64_encode(void *mem_ctx, const char *buf, int len)
154 {
155         const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
156         int bit_offset, byte_offset, idx, i;
157         const uint8_t *d = (const uint8_t *)buf;
158         int bytes = (len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
159         char *out;
160
161         out = talloc_array(mem_ctx, char, bytes+pad_bytes+1);
162         if (!out) return NULL;
163
164         for (i=0;i<bytes;i++) {
165                 byte_offset = (i*6)/8;
166                 bit_offset = (i*6)%8;
167                 if (bit_offset < 3) {
168                         idx = (d[byte_offset] >> (2-bit_offset)) & 0x3F;
169                 } else {
170                         idx = (d[byte_offset] << (bit_offset-2)) & 0x3F;
171                         if (byte_offset+1 < len) {
172                                 idx |= (d[byte_offset+1] >> (8-(bit_offset-2)));
173                         }
174                 }
175                 out[i] = b64[idx];
176         }
177
178         for (;i<bytes+pad_bytes;i++)
179                 out[i] = '=';
180         out[i] = 0;
181
182         return out;
183 }
184
185 /*
186   see if a buffer should be base64 encoded
187 */
188 int ldb_should_b64_encode(struct ldb_context *ldb, const struct ldb_val *val)
189 {
190         unsigned int i;
191         uint8_t *p = val->data;
192
193         if (ldb->flags & LDB_FLG_SHOW_BINARY) {
194                 return 0;
195         }
196
197         if (val->length == 0) {
198                 return 0;
199         }
200
201         if (p[0] == ' ' || p[0] == ':') {
202                 return 1;
203         }
204
205         for (i=0; i<val->length; i++) {
206                 if (!isprint(p[i]) || p[i] == '\n') {
207                         return 1;
208                 }
209         }
210         return 0;
211 }
212
213 /* this macro is used to handle the return checking on fprintf_fn() */
214 #define CHECK_RET do { if (ret < 0) return ret; total += ret; } while (0)
215
216 /*
217   write a line folded string onto a file
218 */
219 static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *private_data,
220                         const char *buf, size_t length, int start_pos)
221 {
222         unsigned int i;
223         int total=0, ret;
224
225         for (i=0;i<length;i++) {
226                 ret = fprintf_fn(private_data, "%c", buf[i]);
227                 CHECK_RET;
228                 if (i != (length-1) && (i + start_pos) % 77 == 0) {
229                         ret = fprintf_fn(private_data, "\n ");
230                         CHECK_RET;
231                 }
232         }
233
234         return total;
235 }
236
237 #undef CHECK_RET
238
239 /*
240   encode as base64 to a file
241 */
242 static int base64_encode_f(struct ldb_context *ldb,
243                            int (*fprintf_fn)(void *, const char *, ...), 
244                            void *private_data,
245                            const char *buf, int len, int start_pos)
246 {
247         char *b = ldb_base64_encode(ldb, buf, len);
248         int ret;
249
250         if (!b) {
251                 return -1;
252         }
253
254         ret = fold_string(fprintf_fn, private_data, b, strlen(b), start_pos);
255
256         talloc_free(b);
257         return ret;
258 }
259
260
261 static const struct {
262         const char *name;
263         enum ldb_changetype changetype;
264 } ldb_changetypes[] = {
265         {"add",    LDB_CHANGETYPE_ADD},
266         {"delete", LDB_CHANGETYPE_DELETE},
267         {"modify", LDB_CHANGETYPE_MODIFY},
268         {NULL, 0}
269 };
270
271 /* this macro is used to handle the return checking on fprintf_fn() */
272 #define CHECK_RET do { if (ret < 0) { talloc_free(mem_ctx); return ret; } total += ret; } while (0)
273
274 /*
275   write to ldif, using a caller supplied write method
276 */
277 int ldb_ldif_write(struct ldb_context *ldb,
278                    int (*fprintf_fn)(void *, const char *, ...), 
279                    void *private_data,
280                    const struct ldb_ldif *ldif)
281 {
282         TALLOC_CTX *mem_ctx;
283         unsigned int i, j;
284         int total=0, ret;
285         char *p;
286         const struct ldb_message *msg;
287
288         mem_ctx = talloc_named_const(NULL, 0, "ldb_ldif_write");
289
290         msg = ldif->msg;
291         p = ldb_dn_get_extended_linearized(mem_ctx, msg->dn, 1);
292         ret = fprintf_fn(private_data, "dn: %s\n", p);
293         talloc_free(p);
294         CHECK_RET;
295
296         if (ldif->changetype != LDB_CHANGETYPE_NONE) {
297                 for (i=0;ldb_changetypes[i].name;i++) {
298                         if (ldb_changetypes[i].changetype == ldif->changetype) {
299                                 break;
300                         }
301                 }
302                 if (!ldb_changetypes[i].name) {
303                         ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Invalid ldif changetype %d",
304                                   ldif->changetype);
305                         talloc_free(mem_ctx);
306                         return -1;
307                 }
308                 ret = fprintf_fn(private_data, "changetype: %s\n", ldb_changetypes[i].name);
309                 CHECK_RET;
310         }
311
312         for (i=0;i<msg->num_elements;i++) {
313                 const struct ldb_schema_attribute *a;
314
315                 a = ldb_schema_attribute_by_name(ldb, msg->elements[i].name);
316
317                 if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
318                         switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
319                         case LDB_FLAG_MOD_ADD:
320                                 fprintf_fn(private_data, "add: %s\n", 
321                                            msg->elements[i].name);
322                                 break;
323                         case LDB_FLAG_MOD_DELETE:
324                                 fprintf_fn(private_data, "delete: %s\n", 
325                                            msg->elements[i].name);
326                                 break;
327                         case LDB_FLAG_MOD_REPLACE:
328                                 fprintf_fn(private_data, "replace: %s\n", 
329                                            msg->elements[i].name);
330                                 break;
331                         }
332                 }
333
334                 for (j=0;j<msg->elements[i].num_values;j++) {
335                         struct ldb_val v;
336                         ret = a->syntax->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
337                         if (ret != LDB_SUCCESS) {
338                                 v = msg->elements[i].values[j];
339                         }
340                         if (ret != LDB_SUCCESS || ldb_should_b64_encode(ldb, &v)) {
341                                 ret = fprintf_fn(private_data, "%s:: ", 
342                                                  msg->elements[i].name);
343                                 CHECK_RET;
344                                 ret = base64_encode_f(ldb, fprintf_fn, private_data, 
345                                                       (char *)v.data, v.length,
346                                                       strlen(msg->elements[i].name)+3);
347                                 CHECK_RET;
348                                 ret = fprintf_fn(private_data, "\n");
349                                 CHECK_RET;
350                         } else {
351                                 ret = fprintf_fn(private_data, "%s: ", msg->elements[i].name);
352                                 CHECK_RET;
353                                 if (ldb->flags & LDB_FLG_SHOW_BINARY) {
354                                         ret = fprintf_fn(private_data, "%*.*s", 
355                                                          v.length, v.length, (char *)v.data);
356                                 } else {
357                                         ret = fold_string(fprintf_fn, private_data,
358                                                           (char *)v.data, v.length,
359                                                           strlen(msg->elements[i].name)+2);
360                                 }
361                                 CHECK_RET;
362                                 ret = fprintf_fn(private_data, "\n");
363                                 CHECK_RET;
364                         }
365                         if (v.data != msg->elements[i].values[j].data) {
366                                 talloc_free(v.data);
367                         }
368                 }
369                 if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
370                         fprintf_fn(private_data, "-\n");
371                 }
372         }
373         ret = fprintf_fn(private_data,"\n");
374         CHECK_RET;
375
376         return total;
377 }
378
379 #undef CHECK_RET
380
381
382 /*
383   pull a ldif chunk, which is defined as a piece of data ending in \n\n or EOF
384   this routine removes any RFC2849 continuations and comments
385
386   caller frees
387 */
388 static char *next_chunk(struct ldb_context *ldb, 
389                         int (*fgetc_fn)(void *), void *private_data)
390 {
391         size_t alloc_size=0, chunk_size = 0;
392         char *chunk = NULL;
393         int c;
394         int in_comment = 0;
395
396         while ((c = fgetc_fn(private_data)) != EOF) {
397                 if (chunk_size+1 >= alloc_size) {
398                         char *c2;
399                         alloc_size += 1024;
400                         c2 = talloc_realloc(ldb, chunk, char, alloc_size);
401                         if (!c2) {
402                                 talloc_free(chunk);
403                                 errno = ENOMEM;
404                                 return NULL;
405                         }
406                         chunk = c2;
407                 }
408
409                 if (in_comment) {
410                         if (c == '\n') {
411                                 in_comment = 0;
412                         }
413                         continue;                       
414                 }
415                 
416                 /* handle continuation lines - see RFC2849 */
417                 if (c == ' ' && chunk_size > 1 && chunk[chunk_size-1] == '\n') {
418                         chunk_size--;
419                         continue;
420                 }
421                 
422                 /* chunks are terminated by a double line-feed */
423                 if (c == '\n' && chunk_size > 0 && chunk[chunk_size-1] == '\n') {
424                         chunk[chunk_size-1] = 0;
425                         return chunk;
426                 }
427
428                 if (c == '#' && (chunk_size == 0 || chunk[chunk_size-1] == '\n')) {
429                         in_comment = 1;
430                         continue;
431                 }
432
433                 /* ignore leading blank lines */
434                 if (chunk_size == 0 && c == '\n') {
435                         continue;
436                 }
437
438                 chunk[chunk_size++] = c;
439         }
440
441         if (chunk) {
442                 chunk[chunk_size] = 0;
443         }
444
445         return chunk;
446 }
447
448
449 /* simple ldif attribute parser */
450 static int next_attr(void *mem_ctx, char **s, const char **attr, struct ldb_val *value)
451 {
452         char *p;
453         int base64_encoded = 0;
454         int binary_file = 0;
455
456         if (strncmp(*s, "-\n", 2) == 0) {
457                 value->length = 0;
458                 *attr = "-";
459                 *s += 2;
460                 return 0;
461         }
462
463         p = strchr(*s, ':');
464         if (!p) {
465                 return -1;
466         }
467
468         *p++ = 0;
469
470         if (*p == ':') {
471                 base64_encoded = 1;
472                 p++;
473         }
474
475         if (*p == '<') {
476                 binary_file = 1;
477                 p++;
478         }
479
480         *attr = *s;
481
482         while (*p == ' ' || *p == '\t') {
483                 p++;
484         }
485
486         value->data = (uint8_t *)p;
487
488         p = strchr(p, '\n');
489
490         if (!p) {
491                 value->length = strlen((char *)value->data);
492                 *s = ((char *)value->data) + value->length;
493         } else {
494                 value->length = p - (char *)value->data;
495                 *s = p+1;
496                 *p = 0;
497         }
498
499         if (base64_encoded) {
500                 int len = ldb_base64_decode((char *)value->data);
501                 if (len == -1) {
502                         /* it wasn't valid base64 data */
503                         return -1;
504                 }
505                 value->length = len;
506         }
507
508         if (binary_file) {
509                 int len = ldb_read_data_file(mem_ctx, value);
510                 if (len == -1) {
511                         /* an error occured hile trying to retrieve the file */
512                         return -1;
513                 }
514         }
515
516         return 0;
517 }
518
519
520 /*
521   free a message from a ldif_read
522 */
523 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
524 {
525         talloc_free(ldif);
526 }
527
528 /*
529  read from a LDIF source, creating a ldb_message
530 */
531 struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
532                                int (*fgetc_fn)(void *), void *private_data)
533 {
534         struct ldb_ldif *ldif;
535         struct ldb_message *msg;
536         const char *attr=NULL;
537         char *chunk=NULL, *s;
538         struct ldb_val value;
539         unsigned flags = 0;
540
541         value.data = NULL;
542
543         ldif = talloc(ldb, struct ldb_ldif);
544         if (!ldif) return NULL;
545
546         ldif->msg = talloc(ldif, struct ldb_message);
547         if (ldif->msg == NULL) {
548                 talloc_free(ldif);
549                 return NULL;
550         }
551
552         ldif->changetype = LDB_CHANGETYPE_NONE;
553         msg = ldif->msg;
554
555         msg->dn = NULL;
556         msg->elements = NULL;
557         msg->num_elements = 0;
558
559         chunk = next_chunk(ldb, fgetc_fn, private_data);
560         if (!chunk) {
561                 goto failed;
562         }
563         talloc_steal(ldif, chunk);
564
565         s = chunk;
566
567         if (next_attr(ldif, &s, &attr, &value) != 0) {
568                 goto failed;
569         }
570         
571         /* first line must be a dn */
572         if (ldb_attr_cmp(attr, "dn") != 0) {
573                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: First line of ldif must be a dn not '%s'",
574                           attr);
575                 goto failed;
576         }
577
578         msg->dn = ldb_dn_from_ldb_val(msg, ldb, &value);
579
580         if ( ! ldb_dn_validate(msg->dn)) {
581                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Unable to parse dn '%s'",
582                           (char *)value.data);
583                 goto failed;
584         }
585
586         while (next_attr(ldif, &s, &attr, &value) == 0) {
587                 const struct ldb_schema_attribute *a;
588                 struct ldb_message_element *el;
589                 int ret, empty = 0;
590
591                 if (ldb_attr_cmp(attr, "changetype") == 0) {
592                         int i;
593                         for (i=0;ldb_changetypes[i].name;i++) {
594                                 if (ldb_attr_cmp((char *)value.data, ldb_changetypes[i].name) == 0) {
595                                         ldif->changetype = ldb_changetypes[i].changetype;
596                                         break;
597                                 }
598                         }
599                         if (!ldb_changetypes[i].name) {
600                                 ldb_debug(ldb, LDB_DEBUG_ERROR,
601                                           "Error: Bad ldif changetype '%s'",(char *)value.data);
602                         }
603                         flags = 0;
604                         continue;
605                 }
606
607                 if (ldb_attr_cmp(attr, "add") == 0) {
608                         flags = LDB_FLAG_MOD_ADD;
609                         empty = 1;
610                 }
611                 if (ldb_attr_cmp(attr, "delete") == 0) {
612                         flags = LDB_FLAG_MOD_DELETE;
613                         empty = 1;
614                 }
615                 if (ldb_attr_cmp(attr, "replace") == 0) {
616                         flags = LDB_FLAG_MOD_REPLACE;
617                         empty = 1;
618                 }
619                 if (ldb_attr_cmp(attr, "-") == 0) {
620                         flags = 0;
621                         continue;
622                 }
623
624                 if (empty) {
625                         if (ldb_msg_add_empty(msg, (char *)value.data, flags, NULL) != 0) {
626                                 goto failed;
627                         }
628                         continue;
629                 }
630                 
631                 el = &msg->elements[msg->num_elements-1];
632
633                 a = ldb_schema_attribute_by_name(ldb, attr);
634
635                 if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
636                     flags == el->flags) {
637                         /* its a continuation */
638                         el->values = 
639                                 talloc_realloc(msg->elements, el->values, 
640                                                  struct ldb_val, el->num_values+1);
641                         if (!el->values) {
642                                 goto failed;
643                         }
644                         ret = a->syntax->ldif_read_fn(ldb, el->values, &value, &el->values[el->num_values]);
645                         if (ret != 0) {
646                                 goto failed;
647                         }
648                         if (value.length == 0) {
649                                 ldb_debug(ldb, LDB_DEBUG_ERROR,
650                                           "Error: Attribute value cannot be empty for attribute '%s'", el->name);
651                                 goto failed;
652                         }
653                         if (value.data != el->values[el->num_values].data) {
654                                 talloc_steal(el->values, el->values[el->num_values].data);
655                         }
656                         el->num_values++;
657                 } else {
658                         /* its a new attribute */
659                         msg->elements = talloc_realloc(msg, msg->elements, 
660                                                          struct ldb_message_element, 
661                                                          msg->num_elements+1);
662                         if (!msg->elements) {
663                                 goto failed;
664                         }
665                         el = &msg->elements[msg->num_elements];
666                         el->flags = flags;
667                         el->name = talloc_strdup(msg->elements, attr);
668                         el->values = talloc(msg->elements, struct ldb_val);
669                         if (!el->values || !el->name) {
670                                 goto failed;
671                         }
672                         el->num_values = 1;
673                         ret = a->syntax->ldif_read_fn(ldb, el->values, &value, &el->values[0]);
674                         if (ret != 0) {
675                                 goto failed;
676                         }
677                         if (value.data != el->values[0].data) {
678                                 talloc_steal(el->values, el->values[0].data);
679                         }
680                         msg->num_elements++;
681                 }
682         }
683
684         return ldif;
685
686 failed:
687         talloc_free(ldif);
688         return NULL;
689 }
690
691
692
693 /*
694   a wrapper around ldif_read() for reading from FILE*
695 */
696 struct ldif_read_file_state {
697         FILE *f;
698 };
699
700 static int fgetc_file(void *private_data)
701 {
702         struct ldif_read_file_state *state =
703                 (struct ldif_read_file_state *)private_data;
704         return fgetc(state->f);
705 }
706
707 struct ldb_ldif *ldb_ldif_read_file(struct ldb_context *ldb, FILE *f)
708 {
709         struct ldif_read_file_state state;
710         state.f = f;
711         return ldb_ldif_read(ldb, fgetc_file, &state);
712 }
713
714
715 /*
716   a wrapper around ldif_read() for reading from const char*
717 */
718 struct ldif_read_string_state {
719         const char *s;
720 };
721
722 static int fgetc_string(void *private_data)
723 {
724         struct ldif_read_string_state *state =
725                 (struct ldif_read_string_state *)private_data;
726         if (state->s[0] != 0) {
727                 return *state->s++;
728         }
729         return EOF;
730 }
731
732 struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char **s)
733 {
734         struct ldif_read_string_state state;
735         struct ldb_ldif *ldif;
736         state.s = *s;
737         ldif = ldb_ldif_read(ldb, fgetc_string, &state);
738         *s = state.s;
739         return ldif;
740 }
741
742
743 /*
744   wrapper around ldif_write() for a file
745 */
746 struct ldif_write_file_state {
747         FILE *f;
748 };
749
750 static int fprintf_file(void *private_data, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
751
752 static int fprintf_file(void *private_data, const char *fmt, ...)
753 {
754         struct ldif_write_file_state *state =
755                 (struct ldif_write_file_state *)private_data;
756         int ret;
757         va_list ap;
758
759         va_start(ap, fmt);
760         ret = vfprintf(state->f, fmt, ap);
761         va_end(ap);
762         return ret;
763 }
764
765 int ldb_ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *ldif)
766 {
767         struct ldif_write_file_state state;
768         state.f = f;
769         return ldb_ldif_write(ldb, fprintf_file, &state, ldif);
770 }
771
772 /*
773   wrapper around ldif_write() for a string
774 */
775 struct ldif_write_string_state {
776         char *string;
777 };
778
779 static int ldif_printf_string(void *private_data, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
780
781 static int ldif_printf_string(void *private_data, const char *fmt, ...)
782 {
783         struct ldif_write_string_state *state =
784                 (struct ldif_write_string_state *)private_data;
785         va_list ap;
786         size_t oldlen = strlen(state->string);
787         va_start(ap, fmt);
788         
789         state->string = talloc_vasprintf_append(state->string, fmt, ap);
790         va_end(ap);
791         if (!state->string) {
792                 return -1;
793         }
794                 
795         return strlen(state->string) - oldlen;
796 }
797
798 char *ldb_ldif_write_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, 
799                             const struct ldb_ldif *ldif)
800 {
801         struct ldif_write_string_state state;
802         state.string = talloc_strdup(mem_ctx, "");
803         if (!state.string) {
804                 return NULL;
805         }
806         if (ldb_ldif_write(ldb, ldif_printf_string, &state, ldif) == -1) {
807                 return NULL;
808         }
809         return state.string;
810 }
811
812 /*
813   convenient function to turn a ldb_message into a string. Useful for
814   debugging
815  */
816 char *ldb_ldif_message_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, 
817                               enum ldb_changetype changetype,
818                               const struct ldb_message *msg)
819 {
820         struct ldb_ldif ldif;
821
822         ldif.changetype = changetype;
823         ldif.msg = discard_const_p(struct ldb_message, msg);
824
825         return ldb_ldif_write_string(ldb, mem_ctx, &ldif);
826 }