4 Copyright (C) Andrew Tridgell 2004
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
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 2 of the License, or (at your option) any later version.
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.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 * Component: ldif routines
30 * Description: ldif pack/unpack routines
32 * Author: Andrew Tridgell
36 see RFC2849 for the LDIF format definition
40 #include "ldb/include/includes.h"
41 #include "system/locale.h"
46 static int ldb_read_data_file(void *mem_ctx
, struct ldb_val
*value
)
50 int count
, size
, bytes
;
53 const char *fname
= (const char *)value
->data
;
55 if (strncmp(fname
, "file://", 7) != 0) {
56 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX
;
60 f
= open(fname
, O_RDONLY
);
65 if (fstat(f
, &statbuf
) != 0) {
70 if (statbuf
.st_size
== 0) {
75 value
->data
= (uint8_t *)talloc_size(mem_ctx
, statbuf
.st_size
+ 1);
76 if (value
->data
== NULL
) {
80 value
->data
[statbuf
.st_size
] = 0;
83 size
= statbuf
.st_size
;
84 buf
= (char *)value
->data
;
85 while (count
< statbuf
.st_size
) {
86 bytes
= read(f
, buf
, size
);
88 talloc_free(value
->data
);
97 value
->length
= statbuf
.st_size
;
98 ret
= statbuf
.st_size
;
106 this base64 decoder was taken from jitterbug (written by tridge).
107 we might need to replace it with a new version
109 int ldb_base64_decode(char *s
)
111 const char *b64
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
112 int bit_offset
=0, byte_offset
, idx
, i
, n
;
113 uint8_t *d
= (uint8_t *)s
;
118 while (*s
&& (p
=strchr(b64
,*s
))) {
119 idx
= (int)(p
- b64
);
120 byte_offset
= (i
*6)/8;
121 bit_offset
= (i
*6)%8;
122 d
[byte_offset
] &= ~((1<<(8-bit_offset
))-1);
123 if (bit_offset
< 3) {
124 d
[byte_offset
] |= (idx
<< (2-bit_offset
));
127 d
[byte_offset
] |= (idx
>> (bit_offset
-2));
128 d
[byte_offset
+1] = 0;
129 d
[byte_offset
+1] |= (idx
<< (8-(bit_offset
-2))) & 0xFF;
134 if (bit_offset
>= 3) {
139 /* the only termination allowed */
155 char *ldb_base64_encode(void *mem_ctx
, const char *buf
, int len
)
157 const char *b64
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
158 int bit_offset
, byte_offset
, idx
, i
;
159 const uint8_t *d
= (const uint8_t *)buf
;
160 int bytes
= (len
*8 + 5)/6, pad_bytes
= (bytes
% 4) ? 4 - (bytes
% 4) : 0;
163 out
= talloc_array(mem_ctx
, char, bytes
+pad_bytes
+1);
164 if (!out
) return NULL
;
166 for (i
=0;i
<bytes
;i
++) {
167 byte_offset
= (i
*6)/8;
168 bit_offset
= (i
*6)%8;
169 if (bit_offset
< 3) {
170 idx
= (d
[byte_offset
] >> (2-bit_offset
)) & 0x3F;
172 idx
= (d
[byte_offset
] << (bit_offset
-2)) & 0x3F;
173 if (byte_offset
+1 < len
) {
174 idx
|= (d
[byte_offset
+1] >> (8-(bit_offset
-2)));
180 for (;i
<bytes
+pad_bytes
;i
++)
188 see if a buffer should be base64 encoded
190 int ldb_should_b64_encode(const struct ldb_val
*val
)
193 uint8_t *p
= val
->data
;
195 if (val
->length
== 0) {
199 if (p
[0] == ' ' || p
[0] == ':') {
203 for (i
=0; i
<val
->length
; i
++) {
204 if (!isprint(p
[i
]) || p
[i
] == '\n') {
211 /* this macro is used to handle the return checking on fprintf_fn() */
212 #define CHECK_RET do { if (ret < 0) return ret; total += ret; } while (0)
215 write a line folded string onto a file
217 static int fold_string(int (*fprintf_fn
)(void *, const char *, ...), void *private_data
,
218 const char *buf
, size_t length
, int start_pos
)
223 for (i
=0;i
<length
;i
++) {
224 ret
= fprintf_fn(private_data
, "%c", buf
[i
]);
226 if (i
!= (length
-1) && (i
+ start_pos
) % 77 == 0) {
227 ret
= fprintf_fn(private_data
, "\n ");
238 encode as base64 to a file
240 static int base64_encode_f(struct ldb_context
*ldb
,
241 int (*fprintf_fn
)(void *, const char *, ...),
243 const char *buf
, int len
, int start_pos
)
245 char *b
= ldb_base64_encode(ldb
, buf
, len
);
252 ret
= fold_string(fprintf_fn
, private_data
, b
, strlen(b
), start_pos
);
259 static const struct {
261 enum ldb_changetype changetype
;
262 } ldb_changetypes
[] = {
263 {"add", LDB_CHANGETYPE_ADD
},
264 {"delete", LDB_CHANGETYPE_DELETE
},
265 {"modify", LDB_CHANGETYPE_MODIFY
},
269 /* this macro is used to handle the return checking on fprintf_fn() */
270 #define CHECK_RET do { if (ret < 0) { talloc_free(mem_ctx); return ret; } total += ret; } while (0)
273 write to ldif, using a caller supplied write method
275 int ldb_ldif_write(struct ldb_context
*ldb
,
276 int (*fprintf_fn
)(void *, const char *, ...),
278 const struct ldb_ldif
*ldif
)
283 const struct ldb_message
*msg
;
285 mem_ctx
= talloc_named_const(NULL
, 0, "ldb_ldif_write");
289 ret
= fprintf_fn(private_data
, "dn: %s\n", ldb_dn_linearize(msg
->dn
, msg
->dn
));
292 if (ldif
->changetype
!= LDB_CHANGETYPE_NONE
) {
293 for (i
=0;ldb_changetypes
[i
].name
;i
++) {
294 if (ldb_changetypes
[i
].changetype
== ldif
->changetype
) {
298 if (!ldb_changetypes
[i
].name
) {
299 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "Error: Invalid ldif changetype %d\n",
301 talloc_free(mem_ctx
);
304 ret
= fprintf_fn(private_data
, "changetype: %s\n", ldb_changetypes
[i
].name
);
308 for (i
=0;i
<msg
->num_elements
;i
++) {
309 const struct ldb_attrib_handler
*h
;
311 h
= ldb_attrib_handler(ldb
, msg
->elements
[i
].name
);
313 if (ldif
->changetype
== LDB_CHANGETYPE_MODIFY
) {
314 switch (msg
->elements
[i
].flags
& LDB_FLAG_MOD_MASK
) {
315 case LDB_FLAG_MOD_ADD
:
316 fprintf_fn(private_data
, "add: %s\n",
317 msg
->elements
[i
].name
);
319 case LDB_FLAG_MOD_DELETE
:
320 fprintf_fn(private_data
, "delete: %s\n",
321 msg
->elements
[i
].name
);
323 case LDB_FLAG_MOD_REPLACE
:
324 fprintf_fn(private_data
, "replace: %s\n",
325 msg
->elements
[i
].name
);
330 for (j
=0;j
<msg
->elements
[i
].num_values
;j
++) {
332 ret
= h
->ldif_write_fn(ldb
, mem_ctx
, &msg
->elements
[i
].values
[j
], &v
);
334 if (ldb_should_b64_encode(&v
)) {
335 ret
= fprintf_fn(private_data
, "%s:: ",
336 msg
->elements
[i
].name
);
338 ret
= base64_encode_f(ldb
, fprintf_fn
, private_data
,
339 (char *)v
.data
, v
.length
,
340 strlen(msg
->elements
[i
].name
)+3);
342 ret
= fprintf_fn(private_data
, "\n");
345 ret
= fprintf_fn(private_data
, "%s: ", msg
->elements
[i
].name
);
347 ret
= fold_string(fprintf_fn
, private_data
,
348 (char *)v
.data
, v
.length
,
349 strlen(msg
->elements
[i
].name
)+2);
351 ret
= fprintf_fn(private_data
, "\n");
354 if (v
.data
!= msg
->elements
[i
].values
[j
].data
) {
358 if (ldif
->changetype
== LDB_CHANGETYPE_MODIFY
) {
359 fprintf_fn(private_data
, "-\n");
362 ret
= fprintf_fn(private_data
,"\n");
372 pull a ldif chunk, which is defined as a piece of data ending in \n\n or EOF
373 this routine removes any RFC2849 continuations and comments
377 static char *next_chunk(struct ldb_context
*ldb
,
378 int (*fgetc_fn
)(void *), void *private_data
)
380 size_t alloc_size
=0, chunk_size
= 0;
385 while ((c
= fgetc_fn(private_data
)) != EOF
) {
386 if (chunk_size
+1 >= alloc_size
) {
389 c2
= talloc_realloc(ldb
, chunk
, char, alloc_size
);
405 /* handle continuation lines - see RFC2849 */
406 if (c
== ' ' && chunk_size
> 1 && chunk
[chunk_size
-1] == '\n') {
411 /* chunks are terminated by a double line-feed */
412 if (c
== '\n' && chunk_size
> 0 && chunk
[chunk_size
-1] == '\n') {
413 chunk
[chunk_size
-1] = 0;
417 if (c
== '#' && (chunk_size
== 0 || chunk
[chunk_size
-1] == '\n')) {
422 /* ignore leading blank lines */
423 if (chunk_size
== 0 && c
== '\n') {
427 chunk
[chunk_size
++] = c
;
431 chunk
[chunk_size
] = 0;
438 /* simple ldif attribute parser */
439 static int next_attr(void *mem_ctx
, char **s
, const char **attr
, struct ldb_val
*value
)
442 int base64_encoded
= 0;
445 if (strncmp(*s
, "-\n", 2) == 0) {
471 while (*p
== ' ' || *p
== '\t') {
475 value
->data
= (uint8_t *)p
;
480 value
->length
= strlen((char *)value
->data
);
481 *s
= ((char *)value
->data
) + value
->length
;
483 value
->length
= p
- (char *)value
->data
;
488 if (base64_encoded
) {
489 int len
= ldb_base64_decode((char *)value
->data
);
491 /* it wasn't valid base64 data */
498 int len
= ldb_read_data_file(mem_ctx
, value
);
500 /* an error occured hile trying to retrieve the file */
510 free a message from a ldif_read
512 void ldb_ldif_read_free(struct ldb_context
*ldb
, struct ldb_ldif
*ldif
)
518 read from a LDIF source, creating a ldb_message
520 struct ldb_ldif
*ldb_ldif_read(struct ldb_context
*ldb
,
521 int (*fgetc_fn
)(void *), void *private_data
)
523 struct ldb_ldif
*ldif
;
524 struct ldb_message
*msg
;
525 const char *attr
=NULL
;
526 char *chunk
=NULL
, *s
;
527 struct ldb_val value
;
532 ldif
= talloc(ldb
, struct ldb_ldif
);
533 if (!ldif
) return NULL
;
535 ldif
->msg
= talloc(ldif
, struct ldb_message
);
536 if (ldif
->msg
== NULL
) {
541 ldif
->changetype
= LDB_CHANGETYPE_NONE
;
545 msg
->elements
= NULL
;
546 msg
->num_elements
= 0;
547 msg
->private_data
= NULL
;
549 chunk
= next_chunk(ldb
, fgetc_fn
, private_data
);
553 talloc_steal(ldif
, chunk
);
555 msg
->private_data
= chunk
;
558 if (next_attr(ldif
, &s
, &attr
, &value
) != 0) {
562 /* first line must be a dn */
563 if (ldb_attr_cmp(attr
, "dn") != 0) {
564 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "Error: First line of ldif must be a dn not '%s'\n",
569 msg
->dn
= ldb_dn_explode(msg
, (char *)value
.data
);
571 if (msg
->dn
== NULL
) {
572 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "Error: Unable to parse dn '%s'\n",
577 while (next_attr(ldif
, &s
, &attr
, &value
) == 0) {
578 const struct ldb_attrib_handler
*h
;
579 struct ldb_message_element
*el
;
582 if (ldb_attr_cmp(attr
, "changetype") == 0) {
584 for (i
=0;ldb_changetypes
[i
].name
;i
++) {
585 if (ldb_attr_cmp((char *)value
.data
, ldb_changetypes
[i
].name
) == 0) {
586 ldif
->changetype
= ldb_changetypes
[i
].changetype
;
590 if (!ldb_changetypes
[i
].name
) {
591 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
592 "Error: Bad ldif changetype '%s'\n",(char *)value
.data
);
598 if (ldb_attr_cmp(attr
, "add") == 0) {
599 flags
= LDB_FLAG_MOD_ADD
;
602 if (ldb_attr_cmp(attr
, "delete") == 0) {
603 flags
= LDB_FLAG_MOD_DELETE
;
606 if (ldb_attr_cmp(attr
, "replace") == 0) {
607 flags
= LDB_FLAG_MOD_REPLACE
;
610 if (ldb_attr_cmp(attr
, "-") == 0) {
616 if (ldb_msg_add_empty(msg
, (char *)value
.data
, flags
, NULL
) != 0) {
622 el
= &msg
->elements
[msg
->num_elements
-1];
624 h
= ldb_attrib_handler(ldb
, attr
);
626 if (msg
->num_elements
> 0 && ldb_attr_cmp(attr
, el
->name
) == 0 &&
627 flags
== el
->flags
) {
628 /* its a continuation */
630 talloc_realloc(msg
->elements
, el
->values
,
631 struct ldb_val
, el
->num_values
+1);
635 ret
= h
->ldif_read_fn(ldb
, ldif
, &value
, &el
->values
[el
->num_values
]);
639 if (value
.length
== 0) {
640 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
641 "Error: Attribute value cannot be empty for attribute '%s'\n", el
->name
);
644 if (value
.data
!= el
->values
[el
->num_values
].data
) {
645 talloc_steal(el
->values
, el
->values
[el
->num_values
].data
);
649 /* its a new attribute */
650 msg
->elements
= talloc_realloc(ldif
, msg
->elements
,
651 struct ldb_message_element
,
652 msg
->num_elements
+1);
653 if (!msg
->elements
) {
656 el
= &msg
->elements
[msg
->num_elements
];
658 el
->name
= talloc_strdup(msg
->elements
, attr
);
659 el
->values
= talloc(msg
->elements
, struct ldb_val
);
660 if (!el
->values
|| !el
->name
) {
664 ret
= h
->ldif_read_fn(ldb
, ldif
, &value
, &el
->values
[0]);
668 if (value
.data
!= el
->values
[0].data
) {
669 talloc_steal(el
->values
, el
->values
[0].data
);
685 a wrapper around ldif_read() for reading from FILE*
687 struct ldif_read_file_state
{
691 static int fgetc_file(void *private_data
)
693 struct ldif_read_file_state
*state
=
694 (struct ldif_read_file_state
*)private_data
;
695 return fgetc(state
->f
);
698 struct ldb_ldif
*ldb_ldif_read_file(struct ldb_context
*ldb
, FILE *f
)
700 struct ldif_read_file_state state
;
702 return ldb_ldif_read(ldb
, fgetc_file
, &state
);
707 a wrapper around ldif_read() for reading from const char*
709 struct ldif_read_string_state
{
713 static int fgetc_string(void *private_data
)
715 struct ldif_read_string_state
*state
=
716 (struct ldif_read_string_state
*)private_data
;
717 if (state
->s
[0] != 0) {
723 struct ldb_ldif
*ldb_ldif_read_string(struct ldb_context
*ldb
, const char **s
)
725 struct ldif_read_string_state state
;
726 struct ldb_ldif
*ldif
;
728 ldif
= ldb_ldif_read(ldb
, fgetc_string
, &state
);
735 wrapper around ldif_write() for a file
737 struct ldif_write_file_state
{
741 static int fprintf_file(void *private_data
, const char *fmt
, ...) PRINTF_ATTRIBUTE(2, 3);
743 static int fprintf_file(void *private_data
, const char *fmt
, ...)
745 struct ldif_write_file_state
*state
=
746 (struct ldif_write_file_state
*)private_data
;
751 ret
= vfprintf(state
->f
, fmt
, ap
);
756 int ldb_ldif_write_file(struct ldb_context
*ldb
, FILE *f
, const struct ldb_ldif
*ldif
)
758 struct ldif_write_file_state state
;
760 return ldb_ldif_write(ldb
, fprintf_file
, &state
, ldif
);