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

/* -*-c-*-
 *
 * $Id$
 *
 * Simple key management
 *
 * (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.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <mLib/bits.h>
#include <mLib/hash.h>
#include <mLib/sub.h>
#include <mLib/sym.h>

#include "key.h"

/*----- Useful macros -----------------------------------------------------*/

#define KEY_WRITE(f) do {						\
     if (!(f)->f & KF_WRITE)						\
       return (KERR_READONLY);						\
   } while (0)

#define KEY_MODIFY(f) do { (f)->f |= KF_MODIFIED; } while (0)

#define KEY_LOAD(n) ((n) * 2)

/*----- Iteration and iterators -------------------------------------------*/

/* --- @key_mkiter@ --- *
 *
 * Arguments:	@key_iter *i@ = pointer to iterator object
 *		@key_file *f@ = pointer to file structure
 *
 * Returns:	---
 *
 * Use:		Initializes a key iterator.  The keys are returned by
 *		@key_next@.
 */

void key_mkiter(key_iter *i, key_file *f)
{
  HASH_MKITER(&i->i, &f->byid);
  i->t = time(0);
}

/* --- @key_next@ --- *
 *
 * Arguments:	@key_iter *i@ = pointer to iterator object
 *
 * Returns:	Pointer to next key, or null.
 *
 * Use:		Returns the next key in some arbitrary sequence.
 */

key *key_next(key_iter *i)
{
  hash_base *b;
  key *k;
  do {
    HASH_NEXT(&i->i, b);
    k = (key *)b;
  } while (k && KEY_EXPIRED(i->t, k->exp) && KEY_EXPIRED(i->t, k->del));
  return (k);
}

/*----- Lookup ------------------------------------------------------------*/

/* --- @key_bytype@ --- *
 *
 * Arguments:	@key_file *f@ = key file we want a key from
 *		@const char *type@ = type string for desired key
 *
 * Returns:	Pointer to the best key to use, or null.
 *
 * Use:		Looks up a key by its type.  Returns the key with the latest
 *		expiry time.  This function will not return an expired key.
 */

key *key_bytype(key_file *f, const char *type)
{
  time_t now = time(0);
  key *k;
  key_ref *kr;

  if ((kr = sym_find(&f->bytype, type, -1, 0, 0)) == 0)
    return (0);
  for (k = kr->k; k && KEY_EXPIRED(now, k->exp); k = k->next)
    ;
  return (k);
}

/* --- @key_byid@ --- *
 *
 * Arguments:	@key_file *f@ = key file to find a key from
 *		@uint32 id@ = id to look for
 *
 * Returns:	Key with matching id.
 *
 * Use:		Returns a key given its id.  This function will return an
 *		expired key, but not a deleted one.
 */

key *key_byid(key_file *f, uint32 id)
{
  time_t t = time(0);
  hash_base **bin, *b;

  bin = HASH_BIN(&f->byid, id);
  for (b = *bin; b; b = b->next) {
    if (b->hash == id) {
      key *k = (key *)b;
      if (KEY_EXPIRED(t, k->exp) && KEY_EXPIRED(t, k->del))
	return (0);
      return (k);
    }
  }
  return (0);
}

/* --- @key_bytag@ --- *
 *
 * Arguments:	@key_file *f@ = key file to find a key from
 *		@const char *tag@ = pointer to tag string
 *
 * Returns:	Key with matching id or tag.
 *
 * Use:		Returns a key given its tag or id.  This function will return
 *		an expired key, but not a deleted one.
 */

key *key_bytag(key_file *f, const char *tag)
{
  time_t t = time(0);
  char *p;
  uint32 id;
  key_ref *kr = sym_find(&f->bytag, tag, -1, 0, 0);

  if (kr && !(KEY_EXPIRED(t, kr->k->exp) && KEY_EXPIRED(t, kr->k->del)))
    return (kr->k);
  id = strtoul(tag, &p, 16);
  if (!*p)
    return (key_byid(f, id));
  return (key_bytype(f, tag));
}

/* --- @key_qtag@ --- *
 *
 * Arguments:	@key_file *f@ = key file to find a key from
 *		@const char *tag@ = pointer to tag string
 *		@dstr *d@ = pointer to string for full tag name
 *		@key **k@ = where to store the key pointer
 *		@key_data ***kd@ = where to store the key data pointer
 *
 * Returns:	Zero if OK, nonzero if it failed.
 *
 * Use:		Performs a full lookup on a qualified tag name.  The tag is
 *		qualified by the names of subkeys, separated by dots.  Hence,
 *		a qualified tag is ID|TAG[.TAG...].  The various result
 *		pointers can be null to indicate that the result isn't
 *		interesting.
 */

int key_qtag(key_file *f, const char *tag, dstr *d, key **k, key_data ***kd)
{
  dstr dd = DSTR_INIT;
  const char *q;
  key *kk;
  key_data **kkd;

  /* --- Find the end of the base tag --- */

  if ((q = strchr(tag, '.')) == 0)
    DPUTS(&dd, tag);
  else {
    DPUTM(&dd, tag, q - tag);
    DPUTZ(&dd);
    q++;
  }

  /* --- Look up the key tag --- */

  if ((kk = key_bytag(f, dd.buf)) == 0) {
    dstr_destroy(&dd);
    return (-1);
  }

  /* --- Set the various initial bits of result up --- */

  if (d)
    key_fulltag(kk, d);
  if (k)
    *k = kk;
  kkd = &kk->k;

  /* --- Now dig through the rest of the tag --- */

  if (q) {
    while (*q) {
      key_struct *ks;

      /* --- Stick on the next bit of the fullqtag --- */

      DRESET(&dd);
      while (*q && *q != '.') {
	DPUTC(&dd, *q);
	q++;
      }
      DPUTZ(&dd);
      if (d) {
	DPUTC(d, '.');
	DPUTD(d, &dd);
      }

      /* --- Look up the subkey --- */

      if ((*kkd)->e != KENC_STRUCT) {
	kkd = 0;
	break;
      }
      if ((ks = sym_find(&(*kkd)->u.s, dd.buf, -1, 0, 0)) == 0) {
	kkd = 0;
	break;
      }
      kkd = &ks->k;
    }
  }

  /* --- Return the results --- */

  dstr_destroy(&dd);
  if (!kkd)
    return (-1);
  if (kd)
    *kd = kkd;
  return (0);
}

/*----- Miscellaneous functions -------------------------------------------*/

/* --- @key_delete@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to file block
 *		@key *k@ = key to delete
 *
 * Returns:	Error code (one of the @KERR@ constants).
 *
 * Use:		Removes the given key from the list.  The key file must be
 *		writable.  (Due to the horridness of the data structures,
 *		deleted keys aren't actually removed, just marked so that
 *		they can't be looked up or iterated over.  One upshot of
 *		this is that they don't get written back to the file when
 *		it's closed.)
 */

int key_delete(key_file *f, key *k)
{
  KEY_WRITE(f);
  k->exp = KEXP_EXPIRE;
  k->del = KEXP_EXPIRE;
  KEY_MODIFY(f);
  return (0);
}

/* --- @key_expired@ --- *
 *
 * Arguments:	@key *k@ = pointer to key block
 *
 * Returns:	Zero if the key is OK, nonzero if it's expired.
 */

int key_expired(key *k)
{
  time_t now = time(0);
  return (KEY_EXPIRED(now, k->exp) || KEY_EXPIRED(now, k->del));
}

/* --- @key_expire@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to file block
 *		@key *k@ = pointer to key block
 *
 * Returns:	Error code (one of the @KERR@ constants).
 *
 * Use:		Immediately marks the key as expired.  It may be removed
 *		immediately, if it is no longer required, and will be removed
 *		by a tidy operation when it is no longer required.  The key
 *		file must be writable.
 */

int key_expire(key_file *f, key *k)
{
  KEY_WRITE(f);
  k->exp = KEXP_EXPIRE;
  if (k->del == KEXP_FOREVER)
    k->del = KEXP_EXPIRE;
  KEY_MODIFY(f);
  return (0);
}

/* --- @key_used@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to key file
 *		@key *k@ = pointer to key block
 *		@time_t t@ = when key can be removed
 *
 * Returns:	Zero if OK, nonzero on failure.
 *
 * Use:		Marks a key as being required until a given time.  Even
 *		though the key may expire before then (and won't be returned
 *		by type after that time), it will still be available when
 *		requested explicitly by id.  The key file must be writable.
 *
 *		The only (current) reason for failure is attempting to use
 *		a key which can expire for something which can't.
 */

int key_used(key_file *f, key *k, time_t t)
{
  KEY_WRITE(f);
  if (t == KEXP_FOREVER) {
    if (k->exp != KEXP_FOREVER)
      return (KERR_WILLEXPIRE);
  } else if (k->del >= t)
    return (0);

  k->del = t;
  KEY_MODIFY(f);
  return (0);
}

/* --- @key_fingerprint@ --- *
 *
 * Arguments:	@key *k@ = the key to fingerprint
 *		@ghash *h@ = the hash to use
 *		@const key_filter *kf@ = filter to apply
 *
 * Returns:	Nonzero if the key slightly matched the filter.
 *
 * Use:		Updates the hash context with the key contents.
 */

static int abyname(const void *a, const void *b) {
  key_attr *const *x = a, *const *y = b;
  return (strcmp(SYM_NAME(*x), SYM_NAME(*y)));
}

int key_fingerprint(key *k, ghash *h, const key_filter *kf)
{
  dstr d = DSTR_INIT;
  int rc = 0;
  key_attr *a, **v;
  size_t n, i;
  sym_iter ai;

  if (!key_encode(k->k, &d, kf))
    goto done;
  rc = 1;
  GH_HASHSTR(h, "catacomb-key-fingerprint:");
  GH_HASHU32(h, k->id);
  GH_HASHSTR8(h, k->type);
  GH_HASH(h, d.buf, d.len);
  for (n = 0, sym_mkiter(&ai, &k->a); (a = sym_next(&ai)) != 0; n++);
  if (n) {
    v = xmalloc(n * sizeof(*v));
    for (i = 0, sym_mkiter(&ai, &k->a); (a = sym_next(&ai)) != 0; i++)
      v[i] = a;
    qsort(v, n, sizeof(*v), abyname);
    for (i = 0; i < n; i++) {
      GH_HASHSTR8(h, SYM_NAME(v[i]));
      GH_HASHSTR16(h, v[i]->p);
    }
    xfree(v);
  }
done:
  dstr_destroy(&d);
  return (rc);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
d11a0bf7	1	/* --c--
d11a0bf7	2	*
78660a58	3	* $Id$
d11a0bf7	4	*
	5	* Simple key management
	6	*
	7	* (c) 1999 Straylight/Edgeware
	8	*/
	9
45c0fd36	10	/----- Licensing notice --------------------------------------------------
d11a0bf7	11	*
	12	* This file is part of Catacomb.
	13	*
	14	* Catacomb is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU Library General Public License as
	16	* published by the Free Software Foundation; either version 2 of the
	17	* License, or (at your option) any later version.
45c0fd36	18	*
d11a0bf7	19	* Catacomb is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU Library General Public License for more details.
45c0fd36	23	*
d11a0bf7	24	* You should have received a copy of the GNU Library General Public
	25	* License along with Catacomb; if not, write to the Free
	26	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	27	* MA 02111-1307, USA.
	28	*/
	29
d11a0bf7	30	/----- Header files ------------------------------------------------------/
	31
	32	#include <stdio.h>
	33	#include <stdlib.h>
	34	#include <string.h>
	35	#include <time.h>
	36
d11a0bf7	37	#include <mLib/bits.h>
	38	#include <mLib/hash.h>
	39	#include <mLib/sub.h>
	40	#include <mLib/sym.h>
	41
	42	#include "key.h"
	43
	44	/----- Useful macros -----------------------------------------------------/
	45
	46	#define KEY_WRITE(f) do { \
	47	if (!(f)->f & KF_WRITE) \
	48	return (KERR_READONLY); \
	49	} while (0)
	50
	51	#define KEY_MODIFY(f) do { (f)->f \|= KF_MODIFIED; } while (0)
	52
	53	#define KEY_LOAD(n) ((n) * 2)
	54
d11a0bf7	55	/----- Iteration and iterators -------------------------------------------/
	56
	57	/* --- @key_mkiter@ --- *
	58	*
	59	* Arguments: @key_iter *i@ = pointer to iterator object
	60	* @key_file *f@ = pointer to file structure
	61	*
	62	* Returns: ---
	63	*
	64	* Use: Initializes a key iterator. The keys are returned by
	65	* @key_next@.
	66	*/
	67
	68	void key_mkiter(key_iter i, key_file f)
	69	{
	70	HASH_MKITER(&i->i, &f->byid);
	71	i->t = time(0);
	72	}
	73
	74	/* --- @key_next@ --- *
	75	*
	76	* Arguments: @key_iter *i@ = pointer to iterator object
	77	*
	78	* Returns: Pointer to next key, or null.
	79	*
	80	* Use: Returns the next key in some arbitrary sequence.
	81	*/
	82
	83	key key_next(key_iter i)
	84	{
	85	hash_base *b;
	86	key *k;
	87	do {
	88	HASH_NEXT(&i->i, b);
	89	k = (key *)b;
	90	} while (k && KEY_EXPIRED(i->t, k->exp) && KEY_EXPIRED(i->t, k->del));
	91	return (k);
	92	}
	93
	94	/----- Lookup ------------------------------------------------------------/
	95
	96	/* --- @key_bytype@ --- *
	97	*
	98	* Arguments: @key_file *f@ = key file we want a key from
	99	* @const char *type@ = type string for desired key
	100	*
	101	* Returns: Pointer to the best key to use, or null.
	102	*
	103	* Use: Looks up a key by its type. Returns the key with the latest
	104	* expiry time. This function will not return an expired key.
	105	*/
	106
	107	key key_bytype(key_file f, const char *type)
	108	{
	109	time_t now = time(0);
	110	key *k;
	111	key_ref *kr;
	112
	113	if ((kr = sym_find(&f->bytype, type, -1, 0, 0)) == 0)
	114	return (0);
	115	for (k = kr->k; k && KEY_EXPIRED(now, k->exp); k = k->next)
	116	;
	117	return (k);
	118	}
119
120	/* --- @key_byid@ --- *
121	*
122	* Arguments: @key_file *f@ = key file to find a key from
123	* @uint32 id@ = id to look for
124	*
125	* Returns: Key with matching id.
126	*
127	* Use: Returns a key given its id. This function will return an
128	* expired key, but not a deleted one.
129	*/
130
131	key key_byid(key_file f, uint32 id)
132	{
133	time_t t = time(0);
134	hash_base *bin, b;
135
136	bin = HASH_BIN(&f->byid, id);
137	for (b = *bin; b; b = b->next) {
138	if (b->hash == id) {
139	key k = (key )b;
140	if (KEY_EXPIRED(t, k->exp) && KEY_EXPIRED(t, k->del))
141	return (0);
142	return (k);
143	}
144	}
145	return (0);
146	}
147
148	/* --- @key_bytag@ --- *
149	*
150	* Arguments: @key_file *f@ = key file to find a key from
151	* @const char *tag@ = pointer to tag string
152	*
153	* Returns: Key with matching id or tag.
154	*
155	* Use: Returns a key given its tag or id. This function will return
156	* an expired key, but not a deleted one.
157	*/
158
159	key key_bytag(key_file f, const char *tag)
160	{
161	time_t t = time(0);
162	char *p;
163	uint32 id;
164	key_ref *kr = sym_find(&f->bytag, tag, -1, 0, 0);
165
cdb7e56a	166	if (kr && !(KEY_EXPIRED(t, kr->k->exp) && KEY_EXPIRED(t, kr->k->del)))
d11a0bf7	167	return (kr->k);
	168	id = strtoul(tag, &p, 16);
	169	if (!*p)
	170	return (key_byid(f, id));
	171	return (key_bytype(f, tag));
	172	}
	173
	174	/* --- @key_qtag@ --- *
	175	*
	176	* Arguments: @key_file *f@ = key file to find a key from
	177	* @const char *tag@ = pointer to tag string
	178	* @dstr *d@ = pointer to string for full tag name
	179	* @key **k@ = where to store the key pointer
ef13e9a4	180	* @key_data ***kd@ = where to store the key data pointer
d11a0bf7	181	*
	182	* Returns: Zero if OK, nonzero if it failed.
	183	*
	184	* Use: Performs a full lookup on a qualified tag name. The tag is
	185	* qualified by the names of subkeys, separated by dots. Hence,
	186	* a qualified tag is ID\|TAG[.TAG...]. The various result
	187	* pointers can be null to indicate that the result isn't
ef13e9a4	188	* interesting.
d11a0bf7	189	*/
d11a0bf7	190
ef13e9a4	191	int key_qtag(key_file f, const char tag, dstr d, key k, key_data **kd)
d11a0bf7	192	{
	193	dstr dd = DSTR_INIT;
	194	const char *q;
	195	key *kk;
ef13e9a4	196	key_data **kkd;
d11a0bf7	197
	198	/* --- Find the end of the base tag --- */
	199
	200	if ((q = strchr(tag, '.')) == 0)
	201	DPUTS(&dd, tag);
	202	else {
	203	DPUTM(&dd, tag, q - tag);
	204	DPUTZ(&dd);
	205	q++;
	206	}
	207
	208	/* --- Look up the key tag --- */
	209
	210	if ((kk = key_bytag(f, dd.buf)) == 0) {
	211	dstr_destroy(&dd);
	212	return (-1);
	213	}
	214
	215	/* --- Set the various initial bits of result up --- */
	216
	217	if (d)
	218	key_fulltag(kk, d);
	219	if (k)
	220	*k = kk;
	221	kkd = &kk->k;
	222
	223	/* --- Now dig through the rest of the tag --- */
	224
ef13e9a4	225	if (q) {
	226	while (*q) {
	227	key_struct *ks;
	228
	229	/* --- Stick on the next bit of the fullqtag --- */
	230
	231	DRESET(&dd);
	232	while (q && q != '.') {
	233	DPUTC(&dd, *q);
	234	q++;
	235	}
	236	DPUTZ(&dd);
	237	if (d) {
	238	DPUTC(d, '.');
	239	DPUTD(d, &dd);
	240	}
	241
	242	/* --- Look up the subkey --- */
	243
	244	if ((*kkd)->e != KENC_STRUCT) {
	245	kkd = 0;
	246	break;
	247	}
	248	if ((ks = sym_find(&(*kkd)->u.s, dd.buf, -1, 0, 0)) == 0) {
	249	kkd = 0;
	250	break;
	251	}
	252	kkd = &ks->k;
d11a0bf7	253	}
d11a0bf7	254	}
	255
	256	/* --- Return the results --- */
	257
ef13e9a4	258	dstr_destroy(&dd);
d11a0bf7	259	if (!kkd)
d11a0bf7	260	return (-1);
d11a0bf7	261	if (kd)
	262	*kd = kkd;
	263	return (0);
	264	}
	265
	266	/----- Miscellaneous functions -------------------------------------------/
	267
	268	/* --- @key_delete@ --- *
	269	*
	270	* Arguments: @key_file *f@ = pointer to file block
	271	* @key *k@ = key to delete
	272	*
	273	* Returns: Error code (one of the @KERR@ constants).
	274	*
	275	* Use: Removes the given key from the list. The key file must be
	276	* writable. (Due to the horridness of the data structures,
	277	* deleted keys aren't actually removed, just marked so that
	278	* they can't be looked up or iterated over. One upshot of
	279	* this is that they don't get written back to the file when
	280	* it's closed.)
	281	*/
	282
	283	int key_delete(key_file f, key k)
	284	{
	285	KEY_WRITE(f);
	286	k->exp = KEXP_EXPIRE;
	287	k->del = KEXP_EXPIRE;
	288	KEY_MODIFY(f);
	289	return (0);
	290	}
	291
cdb7e56a	292	/* --- @key_expired@ --- *
	293	*
	294	* Arguments: @key *k@ = pointer to key block
	295	*
	296	* Returns: Zero if the key is OK, nonzero if it's expired.
	297	*/
	298
	299	int key_expired(key *k)
	300	{
	301	time_t now = time(0);
	302	return (KEY_EXPIRED(now, k->exp) \|\| KEY_EXPIRED(now, k->del));
	303	}
	304
d11a0bf7	305	/* --- @key_expire@ --- *
	306	*
	307	* Arguments: @key_file *f@ = pointer to file block
	308	* @key *k@ = pointer to key block
	309	*
	310	* Returns: Error code (one of the @KERR@ constants).
	311	*
	312	* Use: Immediately marks the key as expired. It may be removed
	313	* immediately, if it is no longer required, and will be removed
	314	* by a tidy operation when it is no longer required. The key
	315	* file must be writable.
	316	*/
	317
	318	int key_expire(key_file f, key k)
	319	{
	320	KEY_WRITE(f);
	321	k->exp = KEXP_EXPIRE;
	322	if (k->del == KEXP_FOREVER)
	323	k->del = KEXP_EXPIRE;
	324	KEY_MODIFY(f);
	325	return (0);
	326	}
	327
	328	/* --- @key_used@ --- *
	329	*
	330	* Arguments: @key_file *f@ = pointer to key file
	331	* @key *k@ = pointer to key block
	332	* @time_t t@ = when key can be removed
	333	*
	334	* Returns: Zero if OK, nonzero on failure.
	335	*
	336	* Use: Marks a key as being required until a given time. Even
	337	* though the key may expire before then (and won't be returned
	338	* by type after that time), it will still be available when
	339	* requested explicitly by id. The key file must be writable.
	340	*
	341	* The only (current) reason for failure is attempting to use
	342	* a key which can expire for something which can't.
	343	*/
	344
	345	int key_used(key_file f, key k, time_t t)
	346	{
	347	KEY_WRITE(f);
	348	if (t == KEXP_FOREVER) {
	349	if (k->exp != KEXP_FOREVER)
	350	return (KERR_WILLEXPIRE);
	351	} else if (k->del >= t)
	352	return (0);
	353
	354	k->del = t;
	355	KEY_MODIFY(f);
	356	return (0);
	357	}
	358
981bf127	359	/* --- @key_fingerprint@ --- *
	360	*
	361	* Arguments: @key *k@ = the key to fingerprint
	362	* @ghash *h@ = the hash to use
	363	* @const key_filter *kf@ = filter to apply
	364	*
	365	* Returns: Nonzero if the key slightly matched the filter.
	366	*
	367	* Use: Updates the hash context with the key contents.
	368	*/
	369
	370	static int abyname(const void a, const void b) {
	371	key_attr const x = a, const y = b;
	372	return (strcmp(SYM_NAME(x), SYM_NAME(y)));
	373	}
	374
	375	int key_fingerprint(key k, ghash h, const key_filter *kf)
	376	{
	377	dstr d = DSTR_INIT;
	378	int rc = 0;
	379	key_attr a, *v;
78660a58	380	size_t n, i;
981bf127	381	sym_iter ai;
981bf127	382
ef13e9a4	383	if (!key_encode(k->k, &d, kf))
981bf127	384	goto done;
981bf127	385	rc = 1;
78660a58	386	GH_HASHSTR(h, "catacomb-key-fingerprint:");
	387	GH_HASHU32(h, k->id);
	388	GH_HASHSTR8(h, k->type);
981bf127	389	GH_HASH(h, d.buf, d.len);
	390	for (n = 0, sym_mkiter(&ai, &k->a); (a = sym_next(&ai)) != 0; n++);
	391	if (n) {
	392	v = xmalloc(n * sizeof(*v));
	393	for (i = 0, sym_mkiter(&ai, &k->a); (a = sym_next(&ai)) != 0; i++)
	394	v[i] = a;
	395	qsort(v, n, sizeof(*v), abyname);
981bf127	396	for (i = 0; i < n; i++) {
78660a58	397	GH_HASHSTR8(h, SYM_NAME(v[i]));
78660a58	398	GH_HASHSTR16(h, v[i]->p);
981bf127	399	}
981bf127	400	xfree(v);
45c0fd36	401	}
981bf127	402	done:
	403	dstr_destroy(&d);
	404	return (rc);
	405	}
	406
d11a0bf7	407	/----- That's all, folks -------------------------------------------------/