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: ldb pack/unpack
30 * Description: pack/unpack routines for ldb messages as key/value blobs
32 * Author: Andrew Tridgell
36 #include "ldb/include/includes.h"
38 #include "ldb/ldb_tdb/ldb_tdb.h"
40 /* change this if the data format ever changes */
41 #define LTDB_PACKING_FORMAT 0x26011967
43 /* old packing formats */
44 #define LTDB_PACKING_FORMAT_NODN 0x26011966
46 /* use a portable integer format */
47 static void put_uint32(uint8_t *p
, int ofs
, unsigned int val
)
51 p
[1] = (val
>>8) & 0xFF;
52 p
[2] = (val
>>16) & 0xFF;
53 p
[3] = (val
>>24) & 0xFF;
56 static unsigned int pull_uint32(uint8_t *p
, int ofs
)
59 return p
[0] | (p
[1]<<8) | (p
[2]<<16) | (p
[3]<<24);
62 static int attribute_storable_values(const struct ldb_message_element
*el
)
64 if (el
->num_values
== 0) return 0;
66 if (ldb_attr_cmp(el
->name
, "dn") == 0) return 0;
68 if (ldb_attr_cmp(el
->name
, "distinguishedName") == 0) return 0;
70 return el
->num_values
;
74 pack a ldb message into a linear buffer in a TDB_DATA
76 note that this routine avoids saving elements with zero values,
77 as these are equivalent to having no element
79 caller frees the data buffer after use
81 int ltdb_pack_data(struct ldb_module
*module
,
82 const struct ldb_message
*message
,
83 struct TDB_DATA
*data
)
85 struct ldb_context
*ldb
= module
->ldb
;
86 unsigned int i
, j
, real_elements
=0;
92 dn
= ldb_dn_linearize(ldb
, message
->dn
);
98 /* work out how big it needs to be */
101 size
+= 1 + strlen(dn
);
103 for (i
=0;i
<message
->num_elements
;i
++) {
104 if (attribute_storable_values(&message
->elements
[i
]) == 0) {
110 size
+= 1 + strlen(message
->elements
[i
].name
) + 4;
111 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
112 size
+= 4 + message
->elements
[i
].values
[j
].length
+ 1;
117 data
->dptr
= talloc_array(ldb
, uint8_t, size
);
126 put_uint32(p
, 0, LTDB_PACKING_FORMAT
);
127 put_uint32(p
, 4, real_elements
);
130 /* the dn needs to be packed so we can be case preserving
131 while hashing on a case folded dn */
133 memcpy(p
, dn
, len
+1);
136 for (i
=0;i
<message
->num_elements
;i
++) {
137 if (attribute_storable_values(&message
->elements
[i
]) == 0) {
140 len
= strlen(message
->elements
[i
].name
);
141 memcpy(p
, message
->elements
[i
].name
, len
+1);
143 put_uint32(p
, 0, message
->elements
[i
].num_values
);
145 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
146 put_uint32(p
, 0, message
->elements
[i
].values
[j
].length
);
147 memcpy(p
+4, message
->elements
[i
].values
[j
].data
,
148 message
->elements
[i
].values
[j
].length
);
149 p
[4+message
->elements
[i
].values
[j
].length
] = 0;
150 p
+= 4 + message
->elements
[i
].values
[j
].length
+ 1;
159 unpack a ldb message from a linear buffer in TDB_DATA
161 Free with ltdb_unpack_data_free()
163 int ltdb_unpack_data(struct ldb_module
*module
,
164 const struct TDB_DATA
*data
,
165 struct ldb_message
*message
)
167 struct ldb_context
*ldb
= module
->ldb
;
169 unsigned int remaining
;
174 message
->elements
= NULL
;
177 if (data
->dsize
< 8) {
182 format
= pull_uint32(p
, 0);
183 message
->num_elements
= pull_uint32(p
, 4);
186 remaining
= data
->dsize
- 8;
189 case LTDB_PACKING_FORMAT_NODN
:
193 case LTDB_PACKING_FORMAT
:
194 len
= strnlen((char *)p
, remaining
);
195 if (len
== remaining
) {
199 message
->dn
= ldb_dn_explode(message
, (char *)p
);
200 if (message
->dn
== NULL
) {
204 remaining
-= len
+ 1;
213 if (message
->num_elements
== 0) {
214 message
->elements
= NULL
;
218 if (message
->num_elements
> remaining
/ 6) {
223 message
->elements
= talloc_array(message
, struct ldb_message_element
, message
->num_elements
);
224 if (!message
->elements
) {
229 memset(message
->elements
, 0,
230 message
->num_elements
* sizeof(struct ldb_message_element
));
232 for (i
=0;i
<message
->num_elements
;i
++) {
233 if (remaining
< 10) {
237 len
= strnlen((char *)p
, remaining
-6);
238 if (len
== remaining
-6) {
242 message
->elements
[i
].flags
= 0;
243 message
->elements
[i
].name
= talloc_strndup(message
->elements
, (char *)p
, len
);
244 if (message
->elements
[i
].name
== NULL
) {
248 remaining
-= len
+ 1;
250 message
->elements
[i
].num_values
= pull_uint32(p
, 0);
251 message
->elements
[i
].values
= NULL
;
252 if (message
->elements
[i
].num_values
!= 0) {
253 message
->elements
[i
].values
= talloc_array(message
->elements
,
255 message
->elements
[i
].num_values
);
256 if (!message
->elements
[i
].values
) {
263 for (j
=0;j
<message
->elements
[i
].num_values
;j
++) {
264 len
= pull_uint32(p
, 0);
265 if (len
> remaining
-5) {
270 message
->elements
[i
].values
[j
].length
= len
;
271 message
->elements
[i
].values
[j
].data
= talloc_size(message
->elements
[i
].values
, len
+1);
272 if (message
->elements
[i
].values
[j
].data
== NULL
) {
276 memcpy(message
->elements
[i
].values
[j
].data
, p
+4, len
);
277 message
->elements
[i
].values
[j
].data
[len
] = 0;
279 remaining
-= len
+4+1;
284 if (remaining
!= 0) {
285 ldb_debug(ldb
, LDB_DEBUG_ERROR
,
286 "Error: %d bytes unread in ltdb_unpack_data\n", remaining
);
292 talloc_free(message
->elements
);