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 3 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, see <http://www.gnu.org/licenses/>.
27 * Component: ldb pack/unpack
29 * Description: pack/unpack routines for ldb messages as key/value blobs
31 * Author: Andrew Tridgell
36 /* change this if the data format ever changes */
37 #define LTDB_PACKING_FORMAT 0x26011967
39 /* old packing formats */
40 #define LTDB_PACKING_FORMAT_NODN 0x26011966
42 /* use a portable integer format */
43 static void put_uint32(uint8_t *p
, int ofs
, unsigned int val
)
47 p
[1] = (val
>>8) & 0xFF;
48 p
[2] = (val
>>16) & 0xFF;
49 p
[3] = (val
>>24) & 0xFF;
52 static unsigned int pull_uint32(uint8_t *p
, int ofs
)
55 return p
[0] | (p
[1]<<8) | (p
[2]<<16) | (p
[3]<<24);
58 static int attribute_storable_values(const struct ldb_message_element
*el
)
60 if (el
->num_values
== 0) return 0;
62 if (ldb_attr_cmp(el
->name
, "distinguishedName") == 0) return 0;
64 return el
->num_values
;
68 pack a ldb message into a linear buffer in a TDB_DATA
70 note that this routine avoids saving elements with zero values,
71 as these are equivalent to having no element
73 caller frees the data buffer after use
75 int ltdb_pack_data(struct ldb_module
*module
,
76 const struct ldb_message
*message
,
79 struct ldb_context
*ldb
;
80 unsigned int i
, j
, real_elements
=0;
86 ldb
= ldb_module_get_ctx(module
);
88 dn
= ldb_dn_get_linearized(message
->dn
);
94 /* work out how big it needs to be */
97 size
+= 1 + strlen(dn
);
99 for (i
=0;i
<message
->num_elements
;i
++) {
100 if (attribute_storable_values(&message
->elements
[i
]) == 0) {
106 size
+= 1 + strlen(message
->elements
[i
].name
) + 4;
107 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
108 size
+= 4 + message
->elements
[i
].values
[j
].length
+ 1;
113 data
->dptr
= talloc_array(ldb
, uint8_t, size
);
121 put_uint32(p
, 0, LTDB_PACKING_FORMAT
);
122 put_uint32(p
, 4, real_elements
);
125 /* the dn needs to be packed so we can be case preserving
126 while hashing on a case folded dn */
128 memcpy(p
, dn
, len
+1);
131 for (i
=0;i
<message
->num_elements
;i
++) {
132 if (attribute_storable_values(&message
->elements
[i
]) == 0) {
135 len
= strlen(message
->elements
[i
].name
);
136 memcpy(p
, message
->elements
[i
].name
, len
+1);
138 put_uint32(p
, 0, message
->elements
[i
].num_values
);
140 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
141 put_uint32(p
, 0, message
->elements
[i
].values
[j
].length
);
142 memcpy(p
+4, message
->elements
[i
].values
[j
].data
,
143 message
->elements
[i
].values
[j
].length
);
144 p
[4+message
->elements
[i
].values
[j
].length
] = 0;
145 p
+= 4 + message
->elements
[i
].values
[j
].length
+ 1;
153 unpack a ldb message from a linear buffer in TDB_DATA
155 Free with ltdb_unpack_data_free()
157 int ltdb_unpack_data(struct ldb_context
*ldb
,
158 const TDB_DATA
*data
,
159 struct ldb_message
*message
)
162 unsigned int remaining
;
167 message
->elements
= NULL
;
170 if (data
->dsize
< 8) {
175 format
= pull_uint32(p
, 0);
176 message
->num_elements
= pull_uint32(p
, 4);
179 remaining
= data
->dsize
- 8;
182 case LTDB_PACKING_FORMAT_NODN
:
186 case LTDB_PACKING_FORMAT
:
187 len
= strnlen((char *)p
, remaining
);
188 if (len
== remaining
) {
192 message
->dn
= ldb_dn_new(message
, ldb
, (char *)p
);
193 if (message
->dn
== NULL
) {
197 remaining
-= len
+ 1;
206 if (message
->num_elements
== 0) {
210 if (message
->num_elements
> remaining
/ 6) {
215 message
->elements
= talloc_array(message
, struct ldb_message_element
, message
->num_elements
);
216 if (!message
->elements
) {
221 memset(message
->elements
, 0,
222 message
->num_elements
* sizeof(struct ldb_message_element
));
224 for (i
=0;i
<message
->num_elements
;i
++) {
225 if (remaining
< 10) {
229 len
= strnlen((char *)p
, remaining
-6);
230 if (len
== remaining
-6) {
238 message
->elements
[i
].flags
= 0;
239 message
->elements
[i
].name
= talloc_strndup(message
->elements
, (char *)p
, len
);
240 if (message
->elements
[i
].name
== NULL
) {
244 remaining
-= len
+ 1;
246 message
->elements
[i
].num_values
= pull_uint32(p
, 0);
247 message
->elements
[i
].values
= NULL
;
248 if (message
->elements
[i
].num_values
!= 0) {
249 message
->elements
[i
].values
= talloc_array(message
->elements
,
251 message
->elements
[i
].num_values
);
252 if (!message
->elements
[i
].values
) {
259 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
260 len
= pull_uint32(p
, 0);
261 if (len
> remaining
-5) {
266 message
->elements
[i
].values
[j
].length
= len
;
267 message
->elements
[i
].values
[j
].data
= talloc_size(message
->elements
[i
].values
, len
+1);
268 if (message
->elements
[i
].values
[j
].data
== NULL
) {
272 memcpy(message
->elements
[i
].values
[j
].data
, p
+4, len
);
273 message
->elements
[i
].values
[j
].data
[len
] = 0;
275 remaining
-= len
+4+1;
280 if (remaining
!= 0) {
281 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
282 "Error: %d bytes unread in ltdb_unpack_data", remaining
);
288 talloc_free(message
->elements
);