lib/ldb/ldb_tdb/ldb_pack.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: ldb pack/unpack
  28  *
  29  *  Description: pack/unpack routines for ldb messages as key/value blobs
  30  *
  31  *  Author: Andrew Tridgell
  32  */
  33
  34 #include "ldb_tdb.h"
  35
  36 /* change this if the data format ever changes */
  37 #define LTDB_PACKING_FORMAT 0x26011967
  38
  39 /* old packing formats */
  40 #define LTDB_PACKING_FORMAT_NODN 0x26011966
  41
  42 /* use a portable integer format */
  43 static void put_uint32(uint8_t *p, int ofs, unsigned int val)
  44 {
  45         p += ofs;
  46         p[0] = val&0xFF;
  47         p[1] = (val>>8)  & 0xFF;
  48         p[2] = (val>>16) & 0xFF;
  49         p[3] = (val>>24) & 0xFF;
  50 }
  51
  52 static unsigned int pull_uint32(uint8_t *p, int ofs)
  53 {
  54         p += ofs;
  55         return p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
  56 }
  57
  58 static int attribute_storable_values(const struct ldb_message_element *el)
  59 {
  60         if (el->num_values == 0) return 0;
  61
  62         if (ldb_attr_cmp(el->name, "distinguishedName") == 0) return 0;
  63
  64         return el->num_values;
  65 }
  66
  67 /*
  68   pack a ldb message into a linear buffer in a TDB_DATA
  69
  70   note that this routine avoids saving elements with zero values,
  71   as these are equivalent to having no element
  72
  73   caller frees the data buffer after use
  74 */
  75 int ltdb_pack_data(struct ldb_module *module,
  76                    const struct ldb_message *message,
  77                    TDB_DATA *data)
  78 {
  79         struct ldb_context *ldb;
  80         unsigned int i, j, real_elements=0;
  81         size_t size;
  82         const char *dn;
  83         uint8_t *p;
  84         size_t len;
  85
  86         ldb = ldb_module_get_ctx(module);
  87
  88         dn = ldb_dn_get_linearized(message->dn);
  89         if (dn == NULL) {
  90                 errno = ENOMEM;
  91                 return -1;
  92         }
  93
  94         /* work out how big it needs to be */
  95         size = 8;
  96
  97         size += 1 + strlen(dn);
  98
  99         for (i=0;i<message->num_elements;i++) {
 100                 if (attribute_storable_values(&message->elements[i]) == 0) {
 101                         continue;
 102                 }
 103
 104                 real_elements++;
 105
 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;
 109                 }
 110         }
 111
 112         /* allocate it */
 113         data->dptr = talloc_array(ldb, uint8_t, size);
 114         if (!data->dptr) {
 115                 errno = ENOMEM;
 116                 return -1;
 117         }
 118         data->dsize = size;
 119
 120         p = data->dptr;
 121         put_uint32(p, 0, LTDB_PACKING_FORMAT);
 122         put_uint32(p, 4, real_elements);
 123         p += 8;
 124
 125         /* the dn needs to be packed so we can be case preserving
 126            while hashing on a case folded dn */
 127         len = strlen(dn);
 128         memcpy(p, dn, len+1);
 129         p += len + 1;
 130
 131         for (i=0;i<message->num_elements;i++) {
 132                 if (attribute_storable_values(&message->elements[i]) == 0) {
 133                         continue;
 134                 }
 135                 len = strlen(message->elements[i].name);
 136                 memcpy(p, message->elements[i].name, len+1);
 137                 p += len + 1;
 138                 put_uint32(p, 0, message->elements[i].num_values);
 139                 p += 4;
 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;
 146                 }
 147         }
 148
 149         return 0;
 150 }
 151
 152 /*
 153   unpack a ldb message from a linear buffer in TDB_DATA
 154
 155   Free with ltdb_unpack_data_free()
 156 */
 157 int ltdb_unpack_data(struct ldb_context *ldb,
 158                      const TDB_DATA *data,
 159                      struct ldb_message *message)
 160 {
 161         uint8_t *p;
 162         unsigned int remaining;
 163         unsigned int i, j;
 164         unsigned format;
 165         size_t len;
 166
 167         message->elements = NULL;
 168
 169         p = data->dptr;
 170         if (data->dsize < 8) {
 171                 errno = EIO;
 172                 goto failed;
 173         }
 174
 175         format = pull_uint32(p, 0);
 176         message->num_elements = pull_uint32(p, 4);
 177         p += 8;
 178
 179         remaining = data->dsize - 8;
 180
 181         switch (format) {
 182         case LTDB_PACKING_FORMAT_NODN:
 183                 message->dn = NULL;
 184                 break;
 185
 186         case LTDB_PACKING_FORMAT:
 187                 len = strnlen((char *)p, remaining);
 188                 if (len == remaining) {
 189                         errno = EIO;
 190                         goto failed;
 191                 }
 192                 message->dn = ldb_dn_new(message, ldb, (char *)p);
 193                 if (message->dn == NULL) {
 194                         errno = ENOMEM;
 195                         goto failed;
 196                 }
 197                 remaining -= len + 1;
 198                 p += len + 1;
 199                 break;
 200
 201         default:
 202                 errno = EIO;
 203                 goto failed;
 204         }
 205
 206         if (message->num_elements == 0) {
 207                 return 0;
 208         }
 209
 210         if (message->num_elements > remaining / 6) {
 211                 errno = EIO;
 212                 goto failed;
 213         }
 214
 215         message->elements = talloc_array(message, struct ldb_message_element, message->num_elements);
 216         if (!message->elements) {
 217                 errno = ENOMEM;
 218                 goto failed;
 219         }
 220
 221         memset(message->elements, 0,
 222                message->num_elements * sizeof(struct ldb_message_element));
 223
 224         for (i=0;i<message->num_elements;i++) {
 225                 if (remaining < 10) {
 226                         errno = EIO;
 227                         goto failed;
 228                 }
 229                 len = strnlen((char *)p, remaining-6);
 230                 if (len == remaining-6) {
 231                         errno = EIO;
 232                         goto failed;
 233                 }
 234                 if (len == 0) {
 235                         errno = EIO;
 236                         goto failed;
 237                 }
 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) {
 241                         errno = ENOMEM;
 242                         goto failed;
 243                 }
 244                 remaining -= len + 1;
 245                 p += 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,
 250                                                                      struct ldb_val,
 251                                                                      message->elements[i].num_values);
 252                         if (!message->elements[i].values) {
 253                                 errno = ENOMEM;
 254                                 goto failed;
 255                         }
 256                 }
 257                 p += 4;
 258                 remaining -= 4;
 259                 for (j=0;j<message->elements[i].num_values;j++) {
 260                         len = pull_uint32(p, 0);
 261                         if (len > remaining-5) {
 262                                 errno = EIO;
 263                                 goto failed;
 264                         }
 265
 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) {
 269                                 errno = ENOMEM;
 270                                 goto failed;
 271                         }
 272                         memcpy(message->elements[i].values[j].data, p+4, len);
 273                         message->elements[i].values[j].data[len] = 0;
 274
 275                         remaining -= len+4+1;
 276                         p += len+4+1;
 277                 }
 278         }
 279
 280         if (remaining != 0) {
 281                 ldb_debug(ldb, LDB_DEBUG_ERROR,
 282                           "Error: %d bytes unread in ltdb_unpack_data", remaining);
 283         }
 284
 285         return 0;
 286
 287 failed:
 288         talloc_free(message->elements);
 289         return -1;
 290 }