 @@ -72,38 +72,39 @@ typedef struct pgpv_fingerprint_t {
 	uint8_t			v[PGPV_MAX_HASH_LEN];	/* the digest */
 	uint32_t		len;		/* its length */
 } pgpv_fingerprint_t;
 /* specify size for array of bignums */
 #define PGPV_MAX_PUBKEY_BN	4
 /* public key */
 typedef struct pgpv_pubkey_t {
 	pgpv_fingerprint_t	 fingerprint;	/* key fingerprint i.e. digest */
 	uint8_t			 keyid[PGPV_KEYID_LEN];	/* last 8 bytes of v4 keys */
 	int64_t		 	 birth;		/* creation time */
 	int64_t			 expiry;	/* expiry time */
-	pgpv_bignum_t		 bn[PGPV_MAX_PUBKEY_BN];	/* bignums */
+	pgpv_bignum_t		 bn[PGPV_MAX_PUBKEY_BN]; /* bignums */
 	uint8_t			 keyalg;	/* key algorithm */
 	uint8_t			 hashalg;	/* hash algorithm */
 	uint8_t			 version;	/* key version */
 } pgpv_pubkey_t;
 #define PGPV_MAX_SESSKEY_BN	2
 /* a (size, byte array) string */
 typedef struct pgpv_string_t {
 	size_t			 size;
 	uint8_t			*data;
 	uint8_t			 allocated;
 } pgpv_string_t;
 typedef struct pgpv_ref_t {
 	void			*vp;
 	size_t			 offset;
 	unsigned		 mem;
 } pgpv_ref_t;
 #define PGPV_MAX_SECKEY_BN	4
 typedef struct pgpv_compress_t {
 	pgpv_string_t		 s;
 	uint8_t			 compalg;
 @@ -115,27 +116,27 @@ typedef struct pgpv_trust_t {
 	uint8_t			amount;
 } pgpv_trust_t;
 /* a signature sub packet */
 typedef struct pgpv_sigsubpkt_t {
 	pgpv_string_t		 s;
 	uint8_t			 tag;
 	uint8_t			 critical;
 } pgpv_sigsubpkt_t;
 #define PGPV_MAX_SIG_BN		2
 typedef struct pgpv_signature_t {
-	uint8_t			*signer;		/* key id of signer */
+	uint8_t			 signer[PGPV_KEYID_LEN]; /* key id of signer */
 	pgpv_ref_t		 hashstart;
 	uint8_t			*hash2;
 	uint8_t			*mpi;
 	int64_t			 birth;
 	int64_t			 keyexpiry;
 	int64_t			 expiry;
 	uint32_t		 hashlen;
 	uint8_t			 version;
 	uint8_t			 type;
 	uint8_t			 keyalg;
 	uint8_t			 hashalg;
 	uint8_t			 trustlevel;
 	uint8_t			 trustamount;
 @@ -155,42 +156,42 @@ typedef struct pgpv_signature_t {
 	uint8_t			 pref_compress_alg;
 	uint8_t			 key_server_modify;
 	uint8_t			 notation;
 	uint8_t			 type_key;
 	uint8_t			 primary_userid;
 	uint8_t			 revoked;	/* subtract 1 to get real reason, 0 == not revoked */
 } pgpv_signature_t;
 /* a signature packet */
 typedef struct pgpv_sigpkt_t {
 	pgpv_signature_t	 sig;
 	uint16_t		 subslen;
 	uint16_t		 unhashlen;
-	PGPV_ARRAY(pgpv_sigsubpkt_t, subpkts);
+	PGPV_ARRAY(uint64_t,	 subpackets);
 } pgpv_sigpkt_t;
 /* a one-pass signature packet */
 typedef struct pgpv_onepass_t {
 	uint8_t			 keyid[PGPV_KEYID_LEN];
 	uint8_t			 version;
 	uint8_t			 type;
 	uint8_t			 hashalg;
 	uint8_t			 keyalg;
 	uint8_t			 nested;
 } pgpv_onepass_t;
 /* a literal data packet */
 typedef struct pgpv_litdata_t {
-	uint8_t			*filename;
+	pgpv_string_t		 filename;
 	pgpv_string_t		 s;
 	uint32_t		 secs;
 	uint8_t			 namelen;
 	char			 format;
 	unsigned		 mem;
 	size_t			 offset;
 	size_t			 len;
 } pgpv_litdata_t;
 /* user attributes - images */
 typedef struct pgpv_userattr_t {
 	size_t 			 len;
 	PGPV_ARRAY(pgpv_string_t, subattrs);
 @@ -220,79 +221,85 @@ typedef struct pgpv_pkt_t {
 typedef struct pgpv_mem_t {
 	size_t			 size;
 	size_t			 cc;
 	uint8_t			*mem;
 	FILE			*fp;
 	uint8_t			 dealloc;
 	const char		*allowed;	/* the types of packet that are allowed */
 } pgpv_mem_t;
 /* packet parser */
 typedef struct pgpv_signed_userid_t {
 	pgpv_string_t	 	 userid;
-	PGPV_ARRAY(pgpv_signature_t, sigs);
+	PGPV_ARRAY(uint64_t, 	 signatures);
 	uint8_t			 primary_userid;
 	uint8_t			 revoked;
 } pgpv_signed_userid_t;
 typedef struct pgpv_signed_userattr_t {
 	pgpv_userattr_t	 	 userattr;
-	PGPV_ARRAY(pgpv_signature_t, sigs);
+	PGPV_ARRAY(uint64_t, 	 signatures);
 	uint8_t			 revoked;
 } pgpv_signed_userattr_t;
 typedef struct pgpv_signed_subkey_t {
 	pgpv_pubkey_t	 	 subkey;
 	pgpv_signature_t 	 revoc_self_sig;
-	PGPV_ARRAY(pgpv_signature_t, sigs);
+	PGPV_ARRAY(uint64_t, 	 signatures);
 } pgpv_signed_subkey_t;
 typedef struct pgpv_primarykey_t {
 	pgpv_pubkey_t 		 primary;
 	pgpv_signature_t 	 revoc_self_sig;
-	PGPV_ARRAY(pgpv_signature_t, direct_sigs);
+	PGPV_ARRAY(uint64_t, 	 signatures);
-	PGPV_ARRAY(pgpv_signed_userid_t, signed_userids);
+	PGPV_ARRAY(uint64_t, 	 signed_userids);
-	PGPV_ARRAY(pgpv_signed_userattr_t, signed_userattrs);
+	PGPV_ARRAY(uint64_t, 	 signed_userattrs);
-	PGPV_ARRAY(pgpv_signed_subkey_t, signed_subkeys);
+	PGPV_ARRAY(uint64_t, 	 signed_subkeys);
 	size_t			 fmtsize;
 	uint8_t			 primary_userid;
 } pgpv_primarykey_t;
 /* everything stems from this structure */
 typedef struct pgpv_t {
 	PGPV_ARRAY(pgpv_pkt_t, 	 pkts);		/* packet array */
-	PGPV_ARRAY(pgpv_primarykey_t,	 primaries);	/* array of primary keys */
+	PGPV_ARRAY(pgpv_primarykey_t, primaries);	/* array of primary keys */
 	PGPV_ARRAY(pgpv_mem_t,	 areas);	/* areas we read packets from */
 	PGPV_ARRAY(size_t,	 datastarts);	/* starts of data packets */
 	PGPV_ARRAY(pgpv_signature_t, signatures);	/* all signatures */
 	PGPV_ARRAY(pgpv_signed_userid_t, signed_userids); /* all signed userids */
 	PGPV_ARRAY(pgpv_signed_userattr_t, signed_userattrs); /* all signed user attrs */
 	PGPV_ARRAY(pgpv_signed_subkey_t, signed_subkeys); /* all signed subkeys */
 	PGPV_ARRAY(pgpv_sigsubpkt_t, subpkts);	/* all sub packets */
 	size_t		 	 pkt;		/* when parsing, current pkt number */
 	const char		*op;		/* the operation we're doing */
 	unsigned		 ssh;		/* using ssh keys */
 } pgpv_t;
 #define PGPV_REASON_LEN		128
 /* when searching, we define a cursor, and fill in an array of subscripts */
 typedef struct pgpv_cursor_t {
 	pgpv_t			*pgp;			/* pointer to pgp tree */
 	char			*field;			/* field we're searching on */
 	char			*op;			/* operation we're doing */
 	char			*value;			/* value we're searching for */
 	void			*ptr;			/* for regexps etc */
 	PGPV_ARRAY(uint32_t,	 found);		/* array of matched pimary key subscripts */
 	PGPV_ARRAY(size_t,	 datacookies);		/* cookies to retrieve matched data */
 	int64_t			 sigtime;		/* time of signature */
 	char			 why[PGPV_REASON_LEN];	/* reason for bad signature */
 } pgpv_cursor_t;
 #ifndef USE_ARG
 #define USE_ARG(x)	/*LINTED*/(void)&(x)
 #endif
 #ifndef __dead
 #define __dead				__attribute__((__noreturn__))
 #endif
 #ifndef __printflike
 #define __printflike(n, m)		__attribute__((format(printf,n,m)))
 #endif
 #ifndef MIN
 @@ -1054,42 +1061,43 @@ read_signature_mpis(pgpv_sigpkt_t *sigpk
 			printf("sigpkt->version %d, dsa/elgamal sig weird\n", sigpkt->sig.version);
 			return 0;
+		}
 		break;
 	default:
 		printf("weird type of sig! %d\n", sigpkt->sig.keyalg);
 		return 0;
+	}
 	return 1;
+}
 /* add the signature sub packet to the signature packet */
 static int
-add_subpacket(pgpv_sigpkt_t *sigpkt, uint8_t tag, uint8_t *p, uint16_t len)
+add_subpacket(pgpv_t *pgp, pgpv_sigpkt_t *sigpkt, uint8_t tag, uint8_t *p, uint16_t len)
+{
 	pgpv_sigsubpkt_t	subpkt;
 	memset(&subpkt, 0x0, sizeof(subpkt));
 	subpkt.s.size = len;
 	subpkt.critical = 0;
 	subpkt.tag = tag;
 	subpkt.s.data = p;
-	ARRAY_APPEND(sigpkt->subpkts, subpkt);
+	ARRAY_APPEND(sigpkt->subpackets, ARRAY_COUNT(pgp->subpkts));
 	ARRAY_APPEND(pgp->subpkts, subpkt);
 	return 1;
+}
 /* read the subpackets in the signature */
 static int
-read_sig_subpackets(pgpv_sigpkt_t *sigpkt, uint8_t *p, size_t pktlen)
+read_sig_subpackets(pgpv_t *pgp, pgpv_sigpkt_t *sigpkt, uint8_t *p, size_t pktlen)
+{
 	pgpv_sigsubpkt_t	 subpkt;
 	const int		 is_subpkt = 0;
 	unsigned		 lenlen;
 	unsigned		 i;
 	uint8_t			*start;
 	start = p;
 	for (i = 0 ; (unsigned)(p - start) < sigpkt->subslen ; i++) {
 		memset(&subpkt, 0x0, sizeof(subpkt));
 		subpkt.s.size = get_pkt_len(1, p, 0, is_subpkt);
 		lenlen = get_pkt_len_len(1, p, is_subpkt);
 		if (lenlen > pktlen) {
 @@ -1101,30 +1109,30 @@ read_sig_subpackets(pgpv_sigpkt_t *sigpk
 		subpkt.tag = (*p & SUBPKT_TAG_MASK);
 		p += 1;
 		switch(subpkt.tag) {
 		case SUBPKT_SIG_BIRTH:
 			sigpkt->sig.birth = (int64_t)get_32(p);
 			break;
 		case SUBPKT_SIG_EXPIRY:
 			sigpkt->sig.expiry = (int64_t)get_32(p);
 			break;
 		case SUBPKT_KEY_EXPIRY:
 			sigpkt->sig.keyexpiry = (int64_t)get_32(p);
 			break;
 		case SUBPKT_ISSUER:
-			sigpkt->sig.signer = p;
+			memcpy(sigpkt->sig.signer, p, sizeof(sigpkt->sig.signer));
 			break;
 		case SUBPKT_SIGNER_ID:
-			sigpkt->sig.signer = p;
+			memcpy(sigpkt->sig.signer, p, sizeof(sigpkt->sig.signer));
 			break;
 		case SUBPKT_TRUST_SIG:
 			sigpkt->sig.trustsig = *p;
 			break;
 		case SUBPKT_REGEXP:
 			sigpkt->sig.regexp = (char *)(void *)p;
 			break;
 		case SUBPKT_REVOCABLE:
 			sigpkt->sig.revocable = *p;
 			break;
 		case SUBPKT_PREF_SYMMETRIC_ALG:
 			sigpkt->sig.pref_symm_alg = *p;
 			break;
 @@ -1160,76 +1168,79 @@ read_sig_subpackets(pgpv_sigpkt_t *sigpk
 		case SUBPKT_FEATURES:
 			sigpkt->sig.features = (char *)(void *)p;
 			break;
 		case SUBPKT_REVOCATION_REASON:
 			sigpkt->sig.revoked = *p++ + 1;
 			sigpkt->sig.why_revoked = (char *)(void *)p;
 			break;
 		default:
 			printf("Ignoring unusual/reserved signature subpacket %d\n", subpkt.tag);
 			break;
+		}
 		subpkt.s.data = p;
 		p += subpkt.s.size - 1;
-		ARRAY_APPEND(sigpkt->subpkts, subpkt);
+		ARRAY_APPEND(sigpkt->subpackets, ARRAY_COUNT(pgp->subpkts));
 		ARRAY_APPEND(pgp->subpkts, subpkt);
+	}
 	return 1;
+}
 /* parse signature packet */
 static int
 read_sigpkt(pgpv_t *pgp, uint8_t mement, pgpv_sigpkt_t *sigpkt, uint8_t *p, size_t pktlen)
+{
 	unsigned	 lenlen;
 	uint8_t		*base;
 	make_ref(pgp, mement, &sigpkt->sig.hashstart);
 	base = p;
 	switch(sigpkt->sig.version = *p++) {
 	case 2:
 	case 3:
 		if ((lenlen = *p++) != 5) {
 			printf("read_sigpkt: hashed length not 5\n");
 			return 0;
+		}
 		sigpkt->sig.hashlen = lenlen;
 		/* put birthtime into a subpacket */
 		sigpkt->sig.type = *p++;
-		add_subpacket(sigpkt, SUBPKT_SIG_BIRTH, p, sizeof(uint32_t));
+		add_subpacket(pgp, sigpkt, SUBPKT_SIG_BIRTH, p, sizeof(uint32_t));
 		sigpkt->sig.birth = (int64_t)get_32(p);
 		p += sizeof(uint32_t);
-		sigpkt->sig.signer = p;
+		memcpy(sigpkt->sig.signer, p, sizeof(sigpkt->sig.signer));
-		add_subpacket(sigpkt, SUBPKT_SIGNER_ID, p, PGPV_KEYID_LEN);
+		add_subpacket(pgp, sigpkt, SUBPKT_SIGNER_ID, p, PGPV_KEYID_LEN);
 		p += PGPV_KEYID_LEN;
 		sigpkt->sig.keyalg = *p++;
 		sigpkt->sig.hashalg = *p++;
 		sigpkt->sig.hash2 = p;
 		if (!read_signature_mpis(sigpkt, sigpkt->sig.mpi = p + 2, pktlen)) {
 			printf("read_sigpkt: can't read sigs v3\n");
 			return 0;
+		}
 		break;
 	case 4:
 		sigpkt->sig.type = *p++;
 		sigpkt->sig.keyalg = *p++;
 		sigpkt->sig.hashalg = *p++;
 		sigpkt->subslen = get_16(p);
 		p += sizeof(sigpkt->subslen);
-		if (!read_sig_subpackets(sigpkt, p, pktlen)) {
+		if (!read_sig_subpackets(pgp, sigpkt, p, pktlen)) {
 			printf("read_sigpkt: can't read sig subpackets, v4\n");
 			return 0;
+		}
-		if (!sigpkt->sig.signer) {
+		if (sigpkt->sig.signer[0] == 0x0) {
-			sigpkt->sig.signer = get_ref(&sigpkt->sig.hashstart) + 16;
+			memcpy(sigpkt->sig.signer,
 				get_ref(&sigpkt->sig.hashstart) + 16,
 				sizeof(sigpkt->sig.signer));
+		}
 		p += sigpkt->subslen;
 		sigpkt->sig.hashlen = (unsigned)(p - base);
 		sigpkt->unhashlen = get_16(p);
 		p += sizeof(sigpkt->unhashlen) + sigpkt->unhashlen;
 		sigpkt->sig.hash2 = p;
 		if (!read_signature_mpis(sigpkt, sigpkt->sig.mpi = p + 2, pktlen)) {
 			printf("read_sigpkt: can't read sigs, v4\n");
 			return 0;
+		}
 		break;
 	default:
 		printf("read_sigpkt: unusual signature version (%u)\n", sigpkt->sig.version);
 @@ -1433,28 +1444,29 @@ read_litdata(pgpv_t *pgp, pgpv_litdata_t
 	size_t	cc;
 	cc = 0;
 	switch(litdata->format = p[cc++]) {
 	case LITDATA_BINARY:
 	case LITDATA_TEXT:
 	case LITDATA_UTF8:
 		litdata->namelen = 0;
 		break;
 	default:
 		printf("weird litdata format %u\n", litdata->format);
 		break;
+	}
-	litdata->namelen = p[cc++];
+	litdata->filename.size = litdata->namelen = p[cc++];
-	litdata->filename = &p[cc];
+	litdata->filename.data = &p[cc];
 	litdata->filename.allocated = 0;
 	cc += litdata->namelen;
 	litdata->secs = get_32(&p[cc]);
 	cc += 4;
 	litdata->s.data = &p[cc];
 	litdata->len = litdata->s.size = size - cc;
 	litdata->mem = ARRAY_COUNT(pgp->areas) - 1;
 	litdata->offset = cc;
 	return 1;
+}
 /* parse a single packet */
 static int
 read_pkt(pgpv_t *pgp, pgpv_mem_t *mem)
 @@ -1506,26 +1518,27 @@ read_pkt(pgpv_t *pgp, pgpv_mem_t *mem)
 	case PUBKEY_PKT:
 	case PUB_SUBKEY_PKT:
 		break;
 	case LITDATA_PKT:
 		read_litdata(pgp, &pkt.u.litdata, pkt.s.data, pkt.s.size);
 		break;
 	case TRUST_PKT:
 		pkt.u.trust.level = pkt.s.data[0];
 		pkt.u.trust.amount = pkt.s.data[1];
 		break;
 	case USERID_PKT:
 		pkt.u.userid.size = pkt.s.size;
 		pkt.u.userid.data = pkt.s.data;
 		pkt.u.userid.allocated = 0;
 		break;
 	case COMPRESSED_DATA_PKT:
 		read_compressed(pgp, &pkt.u.compressed, pkt.s.data, pkt.s.size);
 		ARRAY_APPEND(pgp->pkts, pkt);
 		read_all_packets(pgp, &ARRAY_LAST(pgp->areas), pgp->op);
 		break;
 	case USER_ATTRIBUTE_PKT:
 		read_userattr(&pkt.u.userattr, pkt.s.data, pkt.s.size);
 		break;
 	default:
 		printf("hi, need to implement %d, offset %zu\n", pkt.tag, mem->cc);
 		break;
+	}
 @@ -1589,33 +1602,35 @@ static int
 recog_userid(pgpv_t *pgp, pgpv_signed_userid_t *userid)
+{
 	pgpv_signature_t	 signature;
 	pgpv_pkt_t		*pkt;
 	memset(userid, 0x0, sizeof(*userid));
 	if (!pkt_is(pgp, USERID_PKT)) {
 		printf("recog_userid: not %d\n", USERID_PKT);
 		return 0;
+	}
 	pkt = &ARRAY_ELEMENT(pgp->pkts, pgp->pkt);
 	userid->userid.size = pkt->s.size;
 	userid->userid.data = pkt->s.data;
 	userid->userid.allocated = 0;
 	pgp->pkt += 1;
 	while (pkt_is(pgp, SIGNATURE_PKT)) {
 		if (!recog_signature(pgp, &signature)) {
 			printf("recog_userid: can't recognise signature/trust\n");
 			return 0;
+		}
-		ARRAY_APPEND(userid->sigs, signature);
+		ARRAY_APPEND(userid->signatures, ARRAY_COUNT(pgp->signatures));
 		ARRAY_APPEND(pgp->signatures, signature);
 		if (signature.primary_userid) {
 			userid->primary_userid = signature.primary_userid;
+		}
 		if (signature.revoked) {
 			userid->revoked = signature.revoked;
+		}
+	}
 	return 1;
+}
 /* recognise user attributes packet */
 static int
 recog_userattr(pgpv_t *pgp, pgpv_signed_userattr_t *userattr)
 @@ -1624,27 +1639,28 @@ recog_userattr(pgpv_t *pgp, pgpv_signed_
 	memset(userattr, 0x0, sizeof(*userattr));
 	if (!pkt_is(pgp, USER_ATTRIBUTE_PKT)) {
 		printf("recog_userattr: not %d\n", USER_ATTRIBUTE_PKT);
 		return 0;
+	}
 	userattr->userattr = ARRAY_ELEMENT(pgp->pkts, pgp->pkt).u.userattr;
 	pgp->pkt += 1;
 	while (pkt_is(pgp, SIGNATURE_PKT)) {
 		if (!recog_signature(pgp, &signature)) {
 			printf("recog_userattr: can't recognise signature/trust\n");
 			return 0;
+		}
-		ARRAY_APPEND(userattr->sigs, signature);
+		ARRAY_APPEND(userattr->signatures, ARRAY_COUNT(pgp->signatures));
 		ARRAY_APPEND(pgp->signatures, signature);
 		if (signature.revoked) {
 			userattr->revoked = signature.revoked;
+		}
+	}
 	return 1;
+}
 /* recognise a sub key */
 static int
 recog_subkey(pgpv_t *pgp, pgpv_signed_subkey_t *subkey)
+{
 	pgpv_signature_t	 signature;
 	pgpv_pkt_t		*pkt;
 @@ -1658,27 +1674,28 @@ recog_subkey(pgpv_t *pgp, pgpv_signed_su
 	    pkt_sigtype_is(pgp, SIGTYPE_CERT_REVOCATION)) {
 		recog_signature(pgp, &signature);
 		subkey->revoc_self_sig = signature;
+	}
 	do {
 		if (!pkt_is(pgp, SIGNATURE_PKT)) {
 			printf("recog_subkey: not signature packet at %zu\n", pgp->pkt);
 			return 0;
+		}
 		if (!recog_signature(pgp, &signature)) {
 			printf("recog_subkey: bad signature/trust at %zu\n", pgp->pkt);
 			return 0;
+		}
-		ARRAY_APPEND(subkey->sigs, signature);
+		ARRAY_APPEND(subkey->signatures, ARRAY_COUNT(pgp->signatures));
 		ARRAY_APPEND(pgp->signatures, signature);
 		if (signature.keyexpiry) {
 			/* XXX - check it's a good key expiry */
 			subkey->subkey.expiry = signature.keyexpiry;
+		}
 	} while (pkt_is(pgp, SIGNATURE_PKT));
 	return 1;
+}
 /* use a sparse map for the text strings here to save space */
 static const char	*keyalgs[] = {
 	"[Unknown]",
 	"RSA (Encrypt or Sign)",
 	"RSA (Encrypt Only)",
 @@ -1747,87 +1764,97 @@ fmt_pubkey(obuf_t *obuf, pgpv_pubkey_t *
+		}
+	}
 	if (!obuf_add_mem(obuf, "\n", 1)) {
 		return 0;
+	}
 	return fmt_fingerprint(obuf, &pubkey->fingerprint, "fingerprint  ");
+}
 /* we add 1 to revocation value to denote compromised */
 #define COMPROMISED	(0x02 + 1)
 /* format a userid - used to order the userids when formatting */
 static int
-fmt_userid(obuf_t *obuf, pgpv_primarykey_t *primary, uint8_t u)
+fmt_userid(obuf_t *obuf, pgpv_t *pgp, pgpv_primarykey_t *primary, uint8_t u)
+{
 	pgpv_signed_userid_t	*userid;
 	const char		*s;
 	uint64_t		 id;
-	userid = &ARRAY_ELEMENT(primary->signed_userids, u);
+	id = ARRAY_ELEMENT(primary->signed_userids, u);
 	userid = &ARRAY_ELEMENT(pgp->signed_userids, id);
 	s = (userid->revoked == COMPROMISED) ? " [COMPROMISED AND REVOKED]\n" :
 		(userid->revoked) ? " [REVOKED]\n" : "\n";
 	return obuf_add_mem(obuf, "uid           ", 14) &&
 		obuf_add_mem(obuf, userid->userid.data, userid->userid.size) &&
 		obuf_add_mem(obuf, s, strlen(s));
+}
 /* format a trust sig - used to order the userids when formatting */
 static int
-fmt_trust(obuf_t *obuf, pgpv_signed_userid_t *userid, uint32_t u)
+fmt_trust(obuf_t *obuf, pgpv_signature_t *sig)
+{
 	pgpv_signature_t	*sig;
 	sig = &ARRAY_ELEMENT(userid->sigs, u);
 	if (!obuf_add_mem(obuf, "trust          ", 15) ||
-	    !fmt_binary(obuf, sig->signer, 8)) {
+	    !fmt_binary(obuf, sig->signer, PGPV_KEYID_LEN)) {
 		return 0;
+	}
 	return obuf_add_mem(obuf, "\n", 1);
+}
 /* print a primary key, per RFC 4880 */
 static int
-fmt_primary(obuf_t *obuf, pgpv_primarykey_t *primary, unsigned subkey, const char *modifiers)
+fmt_primary(obuf_t *obuf, pgpv_t *pgp, pgpv_primarykey_t *primary, unsigned subkey, const char *modifiers)
+{
 	pgpv_signed_userid_t	*userid;
 	pgpv_signed_subkey_t	*signed_subkey;
 	pgpv_pubkey_t		*pubkey;
 	unsigned		 i;
 	unsigned		 j;
 	uint64_t		 id;
-	pubkey = (subkey == 0) ? &primary->primary : &ARRAY_ELEMENT(primary->signed_subkeys, subkey - 1).subkey;
+	if (subkey == 0) {
 		pubkey = &primary->primary;
 	} else {
 		id = ARRAY_ELEMENT(primary->signed_subkeys, subkey);
 		pubkey = &ARRAY_ELEMENT(pgp->signed_subkeys, id - 1).subkey;
+	}
 	if (!fmt_pubkey(obuf, pubkey, "signature    ")) {
 		return 0;
+	}
-	if (!fmt_userid(obuf, primary, primary->primary_userid)) {
+	if (!fmt_userid(obuf, pgp, primary, primary->primary_userid)) {
 		return 0;
+	}
 	for (i = 0 ; i < ARRAY_COUNT(primary->signed_userids) ; i++) {
 		if (i != primary->primary_userid) {
-			if (!fmt_userid(obuf, primary, i)) {
+			if (!fmt_userid(obuf, pgp, primary, i)) {
 				return 0;
+			}
 			if (strcasecmp(modifiers, "trust") == 0) {
-				userid = &ARRAY_ELEMENT(primary->signed_userids, i);
+				id = ARRAY_ELEMENT(primary->signed_userids, i);
-				for (j = 0 ; j < ARRAY_COUNT(userid->sigs) ; j++) {
+				userid = &ARRAY_ELEMENT(pgp->signed_userids, id);
-					if (!fmt_trust(obuf, userid, j)) {
+				for (j = 0 ; j < ARRAY_COUNT(userid->signatures) ; j++) {
 					if (!fmt_trust(obuf, &ARRAY_ELEMENT(pgp->signatures,
 							ARRAY_ELEMENT(userid->signatures, j)))) {
 						return 0;
+					}
+				}
+			}
+		}
+	}
 	if (strcasecmp(modifiers, "subkeys") == 0) {
 		for (i = 0 ; i < ARRAY_COUNT(primary->signed_subkeys) ; i++) {
-			if (!fmt_pubkey(obuf, &ARRAY_ELEMENT(primary->signed_subkeys, i).subkey, "encryption")) {
+			id = ARRAY_ELEMENT(primary->signed_subkeys, i);
 			signed_subkey = &ARRAY_ELEMENT(pgp->signed_subkeys, id);
 			if (!fmt_pubkey(obuf, &signed_subkey->subkey, "encryption")) {
 				return 0;
+			}
+		}
+	}
 	return obuf_add_mem(obuf, "\n", 1);
+}
 /* check the padding on the signature */
 static int
 rsa_padding_check_none(uint8_t *to, int tlen, const uint8_t *from, int flen, int num)
+{
 	USE_ARG(num);
 @@ -2199,26 +2226,40 @@ find_bin_string(const void *blockarg, si
 		return __UNCONST(blockarg);
+	}
 	if (blen < plen) {
 		return NULL;
+	}
 	for (bp = block = blockarg ; (size_t)(bp - block) < blen - plen + 1 ; bp++) {
 		if (memcmp(bp, pat, plen) == 0) {
 			return __UNCONST(bp);
+		}
+	}
 	return NULL;
+}
 /* store string in allocated memory */
 static uint8_t *
 pgpv_strdup(const char *s)
+{
 	uint8_t	*cp;
 	size_t	 len;
 	len = strlen(s);
 	if ((cp = calloc(len + 1, 1)) != NULL) {
 		memcpy(cp, s, len);
+	}
 	return cp;
+}
 #define SIGSTART	"-----BEGIN PGP SIGNATURE-----\n"
 #define SIGEND		"-----END PGP SIGNATURE-----\n"
 /* for ascii armor, we don't get a onepass packet - make one */
 static const char 	*cons_onepass = "\304\015\003\0\0\0\0\377\377\377\377\377\377\377\377\1";
 /* read ascii armor */
 static int
 read_ascii_armor(pgpv_cursor_t *cursor, pgpv_mem_t *mem, const char *filename)
+{
 	pgpv_onepass_t	*onepass;
 	pgpv_sigpkt_t	*sigpkt;
 	pgpv_pkt_t	 litdata;
 @@ -2231,27 +2272,28 @@ read_ascii_armor(pgpv_cursor_t *cursor,
 	/* cons up litdata pkt */
 	memset(&litdata, 0x0, sizeof(litdata));
 	litdata.u.litdata.mem = ARRAY_COUNT(cursor->pgp->areas) - 1;
 	p = mem->mem;
 	/* jump over signed message line */
 	if ((p = find_bin_string(mem->mem, mem->size, "\n\n",  2)) == NULL) {
 		snprintf(cursor->why, sizeof(cursor->why), "malformed armor at offset 0");
 		return 0;
+	}
 	p += 2;
 	litdata.tag = LITDATA_PKT;
 	litdata.s.data = p;
 	litdata.u.litdata.offset = (size_t)(p - mem->mem);
-	litdata.u.litdata.filename = (uint8_t *)strdup(filename);
+	litdata.u.litdata.filename.data = pgpv_strdup(filename);
 	litdata.u.litdata.filename.allocated = 1;
 	if ((p = find_bin_string(datastart = p, mem->size - litdata.offset, SIGSTART, strlen(SIGSTART))) == NULL) {
 		snprintf(cursor->why, sizeof(cursor->why),
 			"malformed armor - no sig - at %zu", (size_t)(p - mem->mem));
 		return 0;
+	}
 	litdata.u.litdata.len = litdata.s.size = (size_t)(p - datastart);
 	/* this puts p at the newline character, so it will find \n\n if no version */
 	p += strlen(SIGSTART) - 1;
 	if ((p = find_bin_string(p, mem->size, "\n\n",  2)) == NULL) {
 		snprintf(cursor->why, sizeof(cursor->why),
 			"malformed armed signature at %zu", (size_t)(p - mem->mem));
 		return 0;
+	}
 @@ -2404,62 +2446,67 @@ recog_primary_key(pgpv_t *pgp, pgpv_prim
 			printf("recog_primary_key: no signature/trust at PGPV_SIGTYPE_KEY_REVOCATION\n");
 			return 0;
+		}
+	}
 	while (pkt_sigtype_is(pgp, SIGTYPE_DIRECT_KEY)) {
 		if (!recog_signature(pgp, &signature)) {
 			printf("recog_primary_key: no signature/trust at PGPV_SIGTYPE_DIRECT_KEY\n");
 			return 0;
+		}
 		if (signature.keyexpiry) {
 			/* XXX - check it's a good key expiry */
 			primary->primary.expiry = signature.keyexpiry;
+		}
-		ARRAY_APPEND(primary->direct_sigs, signature);
+		ARRAY_APPEND(primary->signatures, ARRAY_COUNT(pgp->signatures));
 		ARRAY_APPEND(pgp->signatures, signature);
+	}
 	/* some keys out there have user ids where they shouldn't */
 	do {
 		if (!recog_userid(pgp, &userid)) {
 			printf("recog_primary_key: not userid\n");
 			return 0;
+		}
-		ARRAY_APPEND(primary->signed_userids, userid);
+		ARRAY_APPEND(primary->signed_userids, ARRAY_COUNT(pgp->signed_userids));
 		ARRAY_APPEND(pgp->signed_userids, userid);
 		if (userid.primary_userid) {
 			primary->primary_userid = ARRAY_COUNT(primary->signed_userids) - 1;
+		}
 		while (pkt_is(pgp, USERID_PKT)) {
 			if (!recog_userid(pgp, &userid)) {
 				printf("recog_primary_key: not signed secondary userid\n");
 				return 0;
+			}
-			ARRAY_APPEND(primary->signed_userids, userid);
+			ARRAY_APPEND(primary->signed_userids, ARRAY_COUNT(pgp->signed_userids));
 			ARRAY_APPEND(pgp->signed_userids, userid);
 			if (userid.primary_userid) {
 				primary->primary_userid = ARRAY_COUNT(primary->signed_userids) - 1;
+			}
+		}
 		while (pkt_is(pgp, USER_ATTRIBUTE_PKT)) {
 			if (!recog_userattr(pgp, &userattr)) {
 				printf("recog_primary_key: not signed user attribute\n");
 				return 0;
+			}
-			ARRAY_APPEND(primary->signed_userattrs, userattr);
+			ARRAY_APPEND(primary->signed_userattrs, ARRAY_COUNT(pgp->signed_userattrs));
 			ARRAY_APPEND(pgp->signed_userattrs, userattr);
+		}
 		while (pkt_is(pgp, PUB_SUBKEY_PKT)) {
 			if (!recog_subkey(pgp, &subkey)) {
 				printf("recog_primary_key: not signed public subkey\n");
 				return 0;
+			}
 			calc_keyid(&subkey.subkey, "sha1");
-			ARRAY_APPEND(primary->signed_subkeys, subkey);
+			ARRAY_APPEND(primary->signed_subkeys, ARRAY_COUNT(pgp->signed_subkeys));
 			ARRAY_APPEND(pgp->signed_subkeys, subkey);
+		}
 	} while (pgp->pkt < ARRAY_COUNT(pgp->pkts) && pkt_is(pgp, USERID_PKT));
 	primary->fmtsize = estimate_primarykey_size(primary);
 	return 1;
+}
 /* parse all of the packets for a given operation */
 static int
 read_all_packets(pgpv_t *pgp, pgpv_mem_t *mem, const char *op)
+{
 	pgpv_primarykey_t	 primary;
 	if (op == NULL) {
 @@ -2678,31 +2725,33 @@ read_ssh_file(pgpv_t *pgp, pgpv_primaryk
 		(void) gethostname(hostname, sizeof(hostname));
 		if (strlen(space + 1) - 1 == 0) {
 			(void) snprintf(owner, sizeof(owner), "<root@%s>",
 					hostname);
 		} else {
 			(void) snprintf(owner, sizeof(owner), "<%.*s>",
 				(int)strlen(space + 1) - 1,
 				space + 1);
+		}
 		calc_keyid(pubkey, "sha1");
 		cc = snprintf(newbuf, sizeof(newbuf), "%s (%s) %s",
 			hostname, f, owner);
 		userid.userid.size = cc;
 		userid.userid.allocated = 1;
 		if ((userid.userid.data = calloc(1, cc + 1)) == NULL) {
 			ok = 0;
 		} else {
 			memcpy(userid.userid.data, newbuf, cc);
-			ARRAY_APPEND(primary->signed_userids, userid);
+			ARRAY_APPEND(primary->signed_userids, ARRAY_COUNT(pgp->signed_userids));
 			ARRAY_APPEND(pgp->signed_userids, userid);
 			primary->fmtsize = estimate_primarykey_size(primary) + 1024;
+		}
+	}
 	(void) free(bin);
 	(void) free(buf);
 	bufgap_close(&bg);
 	return ok;
+}
 /* parse memory according to "op" */
 static int
 read_binary_memory(pgpv_t *pgp, const char *op, const void *memory, size_t size)
+{
 @@ -2745,27 +2794,28 @@ fixup_detached(pgpv_cursor_t *cursor, co
 	onepass = &ARRAY_ELEMENT(cursor->pgp->pkts, el).u.onepass;
 	/* read the original file into litdata */
 	snprintf(original, sizeof(original), "%.*s", (int)(dot - f), f);
 	if (!read_file(cursor->pgp, original)) {
 		printf("can't read file '%s'\n", original);
 		return 0;
+	}
 	memset(&litdata, 0x0, sizeof(litdata));
 	mem = &ARRAY_LAST(cursor->pgp->areas);
 	litdata.tag = LITDATA_PKT;
 	litdata.s.data = mem->mem;
 	litdata.u.litdata.format = LITDATA_BINARY;
 	litdata.u.litdata.offset = 0;
-	litdata.u.litdata.filename = (uint8_t *)strdup(original);
+	litdata.u.litdata.filename.data = pgpv_strdup(original);
 	litdata.u.litdata.filename.allocated = 1;
 	litdata.u.litdata.mem = ARRAY_COUNT(cursor->pgp->areas) - 1;
 	litdata.u.litdata.len = litdata.s.size = mem->size;
 	ARRAY_APPEND(cursor->pgp->pkts, litdata);
 	ARRAY_APPEND(cursor->pgp->pkts, sigpkt);
 	memcpy(onepass->keyid, sigpkt.u.sigpkt.sig.signer, sizeof(onepass->keyid));
 	onepass->hashalg = sigpkt.u.sigpkt.sig.hashalg;
 	onepass->keyalg = sigpkt.u.sigpkt.sig.keyalg;
 	return 1;
+}
 /* match the calculated signature against the one in the signature packet */
 static int
 match_sig(pgpv_cursor_t *cursor, pgpv_signature_t *signature, pgpv_pubkey_t *pubkey, uint8_t *data, size_t size)
 @@ -2804,155 +2854,104 @@ match_sig(pgpv_cursor_t *cursor, pgpv_si
 	if (valid_dates(signature, pubkey, cursor->why, sizeof(cursor->why)) > 0) {
 		return 0;
+	}
 	if (key_expired(pubkey, cursor->why, sizeof(cursor->why))) {
 		return 0;
+	}
 	if (signature->revoked) {
 		snprintf(cursor->why, sizeof(cursor->why), "Signature was revoked");
 		return 0;
+	}
 	return 1;
+}
 /* check return value from getenv */
 static const char *
 nonnull_getenv(const char *key)
 	char	*value;
 	return ((value = getenv(key)) == NULL) ? "" : value;
 /************************************************************************/
 /* start of exported functions */
 /************************************************************************/
 /* close all stuff */
 int
 pgpv_close(pgpv_t *pgp)
 	unsigned	 i;
 	if (pgp == NULL) {
 		return 0;
 	for (i = 0 ; i < ARRAY_COUNT(pgp->areas) ; i++) {
 		if (ARRAY_ELEMENT(pgp->areas, i).size > 0) {
 			closemem(&ARRAY_ELEMENT(pgp->areas, i));
 	return 1;
 /* return the formatted entry for the primary key desired */
 size_t
 pgpv_get_entry(pgpv_t *pgp, unsigned ent, char **s, const char *modifiers)
 	unsigned	subkey;
 	unsigned	prim;
 	obuf_t		obuf;
 	prim = ((ent >> 8) & 0xffffff);
 	subkey = (ent & 0xff);
 	if (s == NULL || pgp == NULL || prim >= ARRAY_COUNT(pgp->primaries)) {
 		return 0;
 	*s = NULL;
 	if (modifiers == NULL || (strcasecmp(modifiers, "trust") != 0 && strcasecmp(modifiers, "subkeys") != 0)) {
 		modifiers = "no-subkeys";
 	memset(&obuf, 0x0, sizeof(obuf));
 	if (!fmt_primary(&obuf, &ARRAY_ELEMENT(pgp->primaries, prim), subkey, modifiers)) {
 		return 0;
 	*s = (char *)obuf.v;
 	return obuf.c;
 /* fixup key id, with birth, keyalg and hashalg value from signature */
 static int
 fixup_ssh_keyid(pgpv_t *pgp, pgpv_signature_t *signature, const char *hashtype)
+{
 	pgpv_pubkey_t	*pubkey;
 	unsigned	 i;
 	for (i = 0 ; i < ARRAY_COUNT(pgp->primaries) ; i++) {
 		pubkey = &ARRAY_ELEMENT(pgp->primaries, i).primary;
 		pubkey->keyalg = signature->keyalg;
 		calc_keyid(pubkey, hashtype);
+	}
 	return 1;
+}
 /* find key id */
 static int
 find_keyid(pgpv_t *pgp, const char *strkeyid, uint8_t *keyid, unsigned *sub)
+{
 	pgpv_signed_subkey_t	*subkey;
 	pgpv_primarykey_t	*prim;
 	unsigned		 i;
 	unsigned		 j;
 	uint64_t		 n;
 	uint8_t			 binkeyid[PGPV_KEYID_LEN];
 	size_t			 off;
 	size_t			 cmp;
 	if (strkeyid == NULL && keyid == NULL) {
 		return 0;
+	}
 	if (strkeyid) {
 		str_to_keyid(strkeyid, binkeyid);
 		cmp = strlen(strkeyid) / 2;
 	} else {
 		memcpy(binkeyid, keyid, sizeof(binkeyid));
 		cmp = PGPV_KEYID_LEN;
+	}
 	*sub = 0;
 	off = PGPV_KEYID_LEN - cmp;
 	for (i = 0 ; i < ARRAY_COUNT(pgp->primaries) ; i++) {
 		prim = &ARRAY_ELEMENT(pgp->primaries, i);
 		if (memcmp(&prim->primary.keyid[off], &binkeyid[off], cmp) == 0) {
 			return i;
+		}
 		for (j = 0 ; j < ARRAY_COUNT(prim->signed_subkeys) ; j++) {
-			subkey = &ARRAY_ELEMENT(prim->signed_subkeys, j);
+			n = ARRAY_ELEMENT(prim->signed_subkeys, j);
 			subkey = &ARRAY_ELEMENT(pgp->signed_subkeys, n);
 			if (memcmp(&subkey->subkey.keyid[off], &binkeyid[off], cmp) == 0) {
 				*sub = j + 1;
 				return i;
+			}
+		}
+	}
 	return -1;
+}
 /* match the signature with the id indexed by 'primary' */
 static int
-match_sig_id(pgpv_cursor_t *cursor, pgpv_signature_t *signature, pgpv_litdata_t *litdata, unsigned primary, unsigned sub)
+match_sig_id(pgpv_cursor_t *cursor, pgpv_t *pgp, pgpv_signature_t *signature, pgpv_litdata_t *litdata, unsigned primary, unsigned sub)
+{
 	pgpv_primarykey_t	*prim;
 	pgpv_pubkey_t		*pubkey;
 	uint64_t		 n;
 	uint8_t			*data;
 	size_t			 insize;
 	cursor->sigtime = signature->birth;
 	/* calc hash on data packet */
 	data = get_literal_data(cursor, litdata, &insize);
 	if (sub == 0) {
 		pubkey = &ARRAY_ELEMENT(cursor->pgp->primaries, primary).primary;
 		return match_sig(cursor, signature, pubkey, data, insize);
+	}
 	prim = &ARRAY_ELEMENT(cursor->pgp->primaries, primary);
-	pubkey = &ARRAY_ELEMENT(prim->signed_subkeys, sub - 1).subkey;
+	n = ARRAY_ELEMENT(prim->signed_subkeys, sub - 1);
 	pubkey = &ARRAY_ELEMENT(pgp->signed_subkeys, n).subkey;
 	return match_sig(cursor, signature, pubkey, data, insize);
+}
 /* return the packet type */
 static const char *
 get_packet_type(uint8_t tag)
+{
 	switch(tag) {
 	case SIGNATURE_PKT:
 		return "signature packet";
 	case ONEPASS_SIGNATURE_PKT:
 		return "onepass signature packet";
 	case PUBKEY_PKT:
 @@ -2966,27 +2965,149 @@ get_packet_type(uint8_t tag)
 	case TRUST_PKT:
 		return "trust packet";
 	case USERID_PKT:
 		return "userid packet";
 	case PUB_SUBKEY_PKT:
 		return "public subkey packet";
 	case USER_ATTRIBUTE_PKT:
 		return "user attribute packet";
 	default:
 		return "[UNKNOWN]";
+	}
+}
-/**************************************************************************/
+/* check return value from getenv */
 static const char *
 nonnull_getenv(const char *key)
+{
 	char	*value;
 	return ((value = getenv(key)) == NULL) ? "" : value;
+}
 /* free an array of bignums */
 static void
 free_bn_array(pgpv_bignum_t *v, unsigned n)
+{
 	unsigned	i;
 	for (i = 0 ; i < n ; i++) {
 		PGPV_BN_free(v[i].bn);
+	}
+}
 /************************************************************************/
 /* start of exported functions */
 /************************************************************************/
 /* close all stuff */
 int
 pgpv_close(pgpv_t *pgp)
+{
 	pgpv_primarykey_t	*primary;
 	pgpv_pkt_t		*pkt;
 	unsigned		 i;
 	if (pgp == NULL) {
 		return 0;
+	}
 	for (i = 0 ; i < ARRAY_COUNT(pgp->areas) ; i++) {
 		if (ARRAY_ELEMENT(pgp->areas, i).size > 0) {
 			closemem(&ARRAY_ELEMENT(pgp->areas, i));
+		}
+	}
         ARRAY_FREE(pgp->areas);
         for (i = 0 ; i < ARRAY_COUNT(pgp->pkts) ; i++) {
                 pkt = &ARRAY_ELEMENT(pgp->pkts, i);
                 switch(pkt->tag) {
                 case SIGNATURE_PKT:
 			free_bn_array(pkt->u.sigpkt.sig.bn, PGPV_MAX_SIG_BN);
                         ARRAY_FREE(pkt->u.sigpkt.subpackets);
                         break;
                 case LITDATA_PKT:
 			if (pkt->u.litdata.filename.allocated) {
 				free(pkt->u.litdata.filename.data);
+			}
                         break;
 		case PUBKEY_PKT:
 			free_bn_array(pkt->u.pubkey.bn, PGPV_MAX_PUBKEY_BN);
 			break;
                 case USERID_PKT:
 			if (pkt->u.userid.allocated) {
 				free(pkt->u.userid.data);
+			}
                         break;
                 case USER_ATTRIBUTE_PKT:
                         ARRAY_FREE(pkt->u.userattr.subattrs);
                         break;
+                }
+        }
         ARRAY_FREE(pgp->pkts);
 	for (i = 0 ; i < ARRAY_COUNT(pgp->primaries) ; i++) {
 		primary = &ARRAY_ELEMENT(pgp->primaries, i);
 		free_bn_array(primary->primary.bn, PGPV_MAX_PUBKEY_BN);
 		ARRAY_FREE(primary->signatures);
 		ARRAY_FREE(primary->signed_userids);
 		ARRAY_FREE(primary->signed_userattrs);
 		ARRAY_FREE(primary->signed_subkeys);
+	}
 	for (i = 0 ; i < ARRAY_COUNT(pgp->signatures) ; i++) {
 		free_bn_array(ARRAY_ELEMENT(pgp->signatures, i).bn, PGPV_MAX_SIG_BN);
+	}
 	ARRAY_FREE(pgp->primaries);
 	ARRAY_FREE(pgp->datastarts);
 	ARRAY_FREE(pgp->signatures);
 	ARRAY_FREE(pgp->signed_userids);
 	ARRAY_FREE(pgp->signed_userattrs);
 	ARRAY_FREE(pgp->signed_subkeys);
 	ARRAY_FREE(pgp->subpkts);
 	return 1;
+}
 /* free resources attached to cursor */
 int
 pgpv_cursor_close(pgpv_cursor_t *cursor)
+{
 	if (cursor) {
 		ARRAY_FREE(cursor->datacookies);
 		ARRAY_FREE(cursor->found);
+	}
 	return 0;
+}
 /* return the formatted entry for the primary key desired */
 size_t
 pgpv_get_entry(pgpv_t *pgp, unsigned ent, char **s, const char *modifiers)
+{
 	unsigned	subkey;
 	unsigned	prim;
 	obuf_t		obuf;
 	prim = ((ent >> 8) & 0xffffff);
 	subkey = (ent & 0xff);
 	if (s == NULL || pgp == NULL || prim >= ARRAY_COUNT(pgp->primaries)) {
 		return 0;
+	}
 	*s = NULL;
 	if (modifiers == NULL || (strcasecmp(modifiers, "trust") != 0 && strcasecmp(modifiers, "subkeys") != 0)) {
 		modifiers = "no-subkeys";
+	}
 	memset(&obuf, 0x0, sizeof(obuf));
 	if (!fmt_primary(&obuf, pgp, &ARRAY_ELEMENT(pgp->primaries, prim), subkey, modifiers)) {
 		return 0;
+	}
 	*s = (char *)obuf.v;
 	return obuf.c;
+}
 /* make a new pgpv struct */
 pgpv_t *
 pgpv_new(void)
+{
 	return calloc(1, sizeof(pgpv_t));
+}
 /* make a new pgpv_cursor struct */
 pgpv_cursor_t *
 pgpv_new_cursor(void)
+{
 	return calloc(1, sizeof(pgpv_cursor_t));
 @@ -3071,27 +3192,27 @@ pgpv_verify(pgpv_cursor_t *cursor, pgpv_
 		fixup_ssh_keyid(cursor->pgp, signature, "sha1");
+	}
 	sub = 0;
 	if ((j = find_keyid(cursor->pgp, NULL, onepass->keyid, &sub)) < 0) {
 		if (!fmt_binary(&obuf, onepass->keyid, (unsigned)sizeof(onepass->keyid))) {
 			snprintf(cursor->why, sizeof(cursor->why), "Memory allocation failure");
 			return 0;
+		}
 		snprintf(cursor->why, sizeof(cursor->why),
 			"Signature key id %.*s not found ",
 			(int)obuf.c, (char *)obuf.v);
 		return 0;
+	}
-	if (!match_sig_id(cursor, signature, litdata, (unsigned)j, sub)) {
+	if (!match_sig_id(cursor, pgp, signature, litdata, (unsigned)j, sub)) {
 		snprintf(cursor->why, sizeof(cursor->why),
 			"Signature does not match %.*s",
 			(int)obuf.c, (char *)obuf.v);
 		return 0;
+	}
 	ARRAY_APPEND(cursor->datacookies, pkt);
 	j = ((j & 0xffffff) << 8) | (sub & 0xff);
 	ARRAY_APPEND(cursor->found, j);
 	return pkt + 1;
+}
 /* set up the pubkey keyring */
 int

 @@ -13,29 +13,29 @@
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef NETPGP_VERIFY_H_
-#define NETPGP_VERIFY_H_	20160704
+#define NETPGP_VERIFY_H_	20160705
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20160704"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20160705"
 #include <sys/types.h>
 #include <inttypes.h>
 struct pgpv_t;
 typedef struct pgpv_t	pgpv_t;
 struct pgpv_cursor_t;
 typedef struct pgpv_cursor_t	pgpv_cursor_t;
 #ifndef __BEGIN_DECLS
 #  if defined(__cplusplus)
 @@ -56,17 +56,18 @@ int pgpv_read_pubring(pgpv_t */*pgp*/, c
 int pgpv_read_ssh_pubkeys(pgpv_t */*pgp*/, const void */*keyring*/, ssize_t /*size*/);
 size_t pgpv_verify(pgpv_cursor_t */*cursor*/, pgpv_t */*pgp*/, const void */*mem/file*/, ssize_t /*size*/);
 size_t pgpv_get_verified(pgpv_cursor_t */*cursor*/, size_t /*cookie*/, char **/*ret*/);
 size_t pgpv_dump(pgpv_t */*pgp*/, char **/*data*/);
 size_t pgpv_get_entry(pgpv_t */*pgp*/, unsigned /*ent*/, char **/*ret*/, const char */*modifiers*/);
 int64_t pgpv_get_cursor_num(pgpv_cursor_t */*cursor*/, const char */*field*/);
 char *pgpv_get_cursor_str(pgpv_cursor_t */*cursor*/, const char */*field*/);
 int pgpv_get_cursor_element(pgpv_cursor_t */*cursor*/, size_t /*element*/);
 int pgpv_close(pgpv_t */*pgp*/);
 int pgpv_cursor_close(pgpv_cursor_t */*cursor*/);
 __END_DECLS
 #endif