data.c

/* -*- show-trailing-whitespace: t; indent-tabs: t -*-
 * Copyright (c) 2003,2004,2005,2006 David Lichteblau
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "common.h"

static named_array *
named_array_new(char *name)
{
      named_array *result = xalloc(sizeof(named_array));
      result->name = name;
      result->array = g_ptr_array_new();
      return result;
}

static void
named_array_free(named_array *na)
{
      free(na->name);
      g_ptr_array_free(na->array, 1);
      free(na);
}

static int
named_array_cmp(named_array *a, named_array *b)
{
      return strcmp(a->name, b->name);
}

int
named_array_ptr_cmp(const void *aa, const void *bb)
{
      named_array *a = *((named_array **) aa);
      named_array *b = *((named_array **) bb);
      return named_array_cmp(a, b);
}

/*
 * entry
 */
tentry *
entry_new(char *dn)
{
      return (tentry *) named_array_new(dn);
}

void
entry_free(tentry *entry)
{
      GPtrArray *attributes = entry_attributes(entry);
      int n = attributes->len;
      int i;

      for (i = 0; i < n; i++)
            attribute_free(g_ptr_array_index(attributes, i));
      named_array_free((named_array *) entry);
}

int
entry_cmp(tentry *e, tentry *f)
{
      return named_array_cmp((named_array *) e, (named_array *) f);
}


/*
 * value
 */
/*
 * attribute
 */
tattribute *
attribute_new(char *ad)
{
      return (tattribute *) named_array_new(ad);
}

void
attribute_free(tattribute *attribute)
{
      GPtrArray *values = attribute_values(attribute);
      int n = values->len;
      int i;

      for (i = 0; i < n; i++)
            g_array_free(g_ptr_array_index(values, i), 1);
      named_array_free((named_array *) attribute);
}

int
attribute_cmp(tattribute *a, tattribute *b)
{
      return named_array_cmp((named_array *) a, (named_array *) b);
}


/*
 * misc
 */
tattribute *
entry_find_attribute(tentry *entry, char *ad, int createp)
{
      GPtrArray *attributes = entry_attributes(entry);
      tattribute *attribute = 0;
      int i;

      for (i = 0; i < attributes->len; i++) {
            tattribute *a = g_ptr_array_index(attributes, i);
            if (!strcmp(attribute_ad(a), ad)) {
                  attribute = a;
                  break;
            }
      }
      if (!attribute && createp) {
            attribute = attribute_new(xdup(ad));
            g_ptr_array_add(attributes, attribute);
      }

      return attribute;
}

void
attribute_append_value(tattribute *attribute, char *data, int n)
{
      GArray *value = g_array_sized_new(0, 0, 1, n);
      g_array_append_vals(value, data, n);
      g_ptr_array_add(attribute_values(attribute), value);
}

int
attribute_find_value(tattribute *attribute, char *data, int n)
{
      int i;
      GPtrArray *values = attribute_values(attribute);
      for (i = 0; i < values->len; i++) {
            GArray *value = values->pdata[i];
            if (value->len == n && !memcmp(value->data, data, n))
                  return i;
      }
      return -1;
}

int
attribute_remove_value(tattribute *a, char *data, int n)
{
      int i = attribute_find_value(a, data, n);
      if (i == -1) return i;
      g_array_free(g_ptr_array_remove_index_fast(attribute_values(a), i), 1);
      return 0;
}

/*
 * Aus irgendwelchen Gruenden habe ich mal beschlossen, GArrays mit chars drin
 * statt GStrings zu nehmen fuer die Attributwerte.  Wie unpraktisch.
 */
char *
array2string(GArray *av)
{
      int n = av->len;
      char *str = xalloc(n + 1);
      memcpy(str, av->data, n);
      str[n] = 0;
      return str;
}

/*
 * allocate a new berval and copy LEN bytes of DATA into it
 */
static struct berval *
dup2berval(char *data, int len)
{
      struct berval *bv = xalloc(sizeof(struct berval));
      bv->bv_val = xalloc(len);
      memcpy(bv->bv_val, data, len);
      bv->bv_len = len;
      return bv;
}

void
xfree_berval(struct berval *bv)
{
      free(bv->bv_val);
      free(bv);
}

struct berval *
string2berval(GArray *s)
{
      return dup2berval(s->data, s->len);
}

struct berval *
gstring2berval(GString *s)
{
      return dup2berval(s->str, s->len);
}

LDAPMod *
attribute2mods(tattribute *attribute)
{
      GPtrArray *values = attribute_values(attribute);
      LDAPMod *m = xalloc(sizeof(LDAPMod));
      int j;

      m->mod_op = LDAP_MOD_BVALUES;
      m->mod_type = xdup(attribute_ad(attribute));
      m->mod_bvalues = xalloc(
            (1 + values->len) * sizeof(struct berval *));

      for (j = 0; j < values->len; j++)
            m->mod_bvalues[j]
                  = string2berval(g_ptr_array_index(values, j));
      m->mod_bvalues[j] = 0;
      return m;
}

LDAPMod **
entry2mods(tentry *entry)
{
      GPtrArray *attributes = entry_attributes(entry);
      LDAPMod **result = xalloc((attributes->len + 1) * sizeof(LDAPMod *));
      int i;

      for (i = 0; i < attributes->len; i++)
            result[i] = attribute2mods(g_ptr_array_index(attributes, i));
      result[i] = 0;
      return result;
}