Major memory management overhaul. Added arena support. Use the secure

[u/mdw/catacomb] / key-data.c

/* -*-c-*-
 *
 * $Id: key-data.c,v 1.3 2000/06/17 11:26:03 mdw Exp $
 *
 * Encoding and decoding of key data
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: key-data.c,v $
 * Revision 1.3  2000/06/17 11:26:03  mdw
 * key_structfind: track minor data structure change, and cope if the
 * subkey isn't available.
 *
 * Revision 1.2  2000/02/12 18:21:02  mdw
 * Overhaul of key management (again).
 *
 * Revision 1.1  1999/12/22 15:47:48  mdw
 * Major key-management revision.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include <mLib/base64.h>
#include <mLib/bits.h>
#include <mLib/dstr.h>
#include <mLib/sub.h>
#include <mLib/sym.h>

#include "key-data.h"
#include "mp.h"
#include "mptext.h"

/*----- Setting new values ------------------------------------------------*/

/* --- @key_binary@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@const void *p@ = pointer to key data
 *		@size_t sz@ = size of the key data
 *
 * Returns:	---
 *
 * Use:		Sets a binary key in a key data block.
 */

void key_binary(key_data *k, const void *p, size_t sz)
{
  k->e = (k->e & ~KF_ENCMASK) | KENC_BINARY;
  k->u.k.k = sub_alloc(sz);
  memcpy(k->u.k.k, p, sz);
  k->u.k.sz = sz;
}

/* --- @key_encrypted@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@const void *p@ = pointer to key data
 *		@size_t sz@ = size of the key data
 *
 * Returns:	---
 *
 * Use:		Sets an encrypted key in a key data block.
 */

void key_encrypted(key_data *k, const void *p, size_t sz)
{
  k->e = (k->e & ~KF_ENCMASK) | KENC_ENCRYPT;
  k->u.k.k = sub_alloc(sz);
  memcpy(k->u.k.k, p, sz);
  k->u.k.sz = sz;
}

/* --- @key_mp@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@mp *m@ = pointer to the value to set
 *
 * Returns:	---
 *
 * Use:		Sets a multiprecision integer key in a key block.
 */

void key_mp(key_data *k, mp *m)
{
  k->e = (k->e & ~KF_ENCMASK) | KENC_MP;
  k->u.m = MP_COPY(m);
}

/* --- @key_structure@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *
 * Returns:	---
 *
 * Use:		Initializes a structured key type.
 */

void key_structure(key_data *k)
{
  k->e = KENC_STRUCT;
  sym_create(&k->u.s);
}

/* --- @key_structfind@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@const char *tag@ = pointer to tag string
 *
 * Returns:	Pointer to key data block, or null.
 *
 * Use:		Looks up the tag in a structured key.
 */

key_data *key_structfind(key_data *k, const char *tag)
{
  key_struct *ks;
  assert(((void)"Key is not structured",
	  (k->e & KF_ENCMASK) == KENC_STRUCT));
  ks = sym_find(&k->u.s, tag, -1, 0, 0);
  if (!ks)
    return (0);
  return (&ks->k);
}

/* --- @key_structcreate@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@const char *tag@ = pointer to tag string
 *
 * Returns:	Pointer to newly created key data.
 *
 * Use:		Creates a new uninitialized subkey.
 */

key_data *key_structcreate(key_data *k, const char *tag)
{
  key_struct *ks;
  unsigned f;

  assert(((void)"Key is not structured", k->e == KENC_STRUCT));
  ks = sym_find(&k->u.s, tag, -1, sizeof(*ks), &f);
  if (f)
    key_destroy(&ks->k);
  ks->k.e = KF_TEMP;
  return (&ks->k);
}

/*----- Miscellaneous operations ------------------------------------------*/

/* --- @key_destroy@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data to destroy
 *
 * Returns:	---
 *
 * Use:		Destroys a lump of key data.
 */

void key_destroy(key_data *k)
{
  switch (k->e & KF_ENCMASK) {
    case KENC_BINARY:
    case KENC_ENCRYPT:
      if (k->e & KF_BURN)
	memset(k->u.k.k, 0, k->u.k.sz);
      sub_free(k->u.k.k, k->u.k.sz);
      break;
    case KENC_MP:
      mp_drop(k->u.m);
      break;
    case KENC_STRUCT: {
      sym_iter i;
      key_struct *ks;

      for (sym_mkiter(&i, &k->u.s); (ks = sym_next(&i)) != 0; ) {
	if (!(ks->k.e & KF_TEMP))
	  key_destroy(&ks->k);
      }
      sym_destroy(&k->u.s);
    } break;
  }
}

/* --- @key_do@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data block
 *		@const key_filter *kf@ = pointer to filter block
 *		@dstr *d@ = pointer to base string
 *		@int (*func)(key_data *kd, dstr *d, void *p@ = function
 *		@void *p@ = argument to function
 *
 * Returns:	Nonzero return code from function, or zero.
 *
 * Use:		Runs a function over all the leaves of a key. 
 */

int key_do(key_data *k, const key_filter *kf, dstr *d,
	   int (*func)(key_data */*kd*/, dstr */*d*/, void */*p*/),
	   void *p)
{
  if (!KEY_MATCH(k, kf))
    return (0);
  if ((k->e & KF_ENCMASK) != KENC_STRUCT)
    return (func(k, d, p));
  else {
    sym_iter i;
    key_struct *ks;
    size_t n;
    int rc;

    if (d)
      n = d->len;
    for (sym_mkiter(&i, &k->u.s); (ks = sym_next(&i)) != 0; ) {
      if (d) {
	d->len = n;
	dstr_putf(d, ".%s", SYM_NAME(ks));
      }
      if ((rc = key_do(&ks->k, kf, d, func, p)) != 0)
	return (rc);
    }
    return (0);
  }
}

/* --- @key_copy@ --- *
 *
 * Arguments:	@key_data *kd@ = pointer to destination data block
 *		@key_data *k@ = pointer to source data block
 *		@const key_filter *kf@ = pointer to filter block
 *
 * Returns:	Nonzero if an item was actually copied.
 *
 * Use:		Copies a chunk of key data from one place to another.
 */

int key_copy(key_data *kd, key_data *k, const key_filter *kf)
{
  kd->e = k->e;

  if (!KEY_MATCH(kd, kf))
    return (0);
  switch (k->e & KF_ENCMASK) {

    /* --- Plain binary data --- */

    case KENC_BINARY:
    case KENC_ENCRYPT:
      kd->u.k.k = sub_alloc(k->u.k.sz);
      memcpy(kd->u.k.k, k->u.k.k, k->u.k.sz);
      kd->u.k.sz = k->u.k.sz;
      break;

    /* --- Multiprecision integers --- */

    case KENC_MP:
      kd->u.m = MP_COPY(k->u.m);
      break;

    /* --- Structured key data --- */

    case KENC_STRUCT: {
      sym_iter i;
      key_struct *ks;
      int rc = 0;

      sym_create(&kd->u.s);
      for (sym_mkiter(&i, &k->u.s); (ks = sym_next(&i)) != 0; ) {
	unsigned f;
	key_struct *kks = sym_find(&kd->u.s, SYM_NAME(ks), -1,
				   sizeof(*kks), &f);
	assert(((void)"Duplicate subkey tags", !f));
	if (key_copy(&kks->k, &ks->k, kf))
	  rc = 1;
	else
	  sym_remove(&kd->u.s, kks);
      }
      if (!rc) {
	sym_destroy(&kd->u.s);
	return (0);
      }
    } break;
  }
  return (1);
}

/*----- That's all, folks -------------------------------------------------*/