 @@ -1,14 +1,14 @@
-/*	$NetBSD: bzlib.c,v 1.2 2014/03/05 04:51:37 agc Exp $	*/
+/*	$NetBSD: bzlib.c,v 1.3 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Library top-level functions.                          ---*/
 /*---                                               bzlib.c ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
 @@ -25,27 +25,27 @@
 .9.0a/b -- no changes in this file.
 .9.0c   -- made zero-length BZ_FLUSH work correctly in bzCompress().
      fixed bzWrite/bzRead to ignore zero-length requests.
      fixed bzread to correctly handle read requests after EOF.
      wrong parameter order in call to bzDecompressInit in
      bzBuffToBuffDecompress.  Fixed.
 */
 #include "config.h"
 #include "bzlib_private.h"
-/*	$NetBSD: bzlib.c,v 1.2 2014/03/05 04:51:37 agc Exp $	*/
+/*	$NetBSD: bzlib.c,v 1.3 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Table for randomising repetitive blocks               ---*/
 /*---                                           randtable.c ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
 @@ -920,26 +920,28 @@ BZFILE * bzopen_or_bzdopen
                  int open_mode)      /* bzopen: 0, bzdopen:1 */
+{
    int    bzerr;
    char   unused[BZ_MAX_UNUSED];
    int    blockSize100k = 9;
    int    writing       = 0;
    char   mode2[10]     = "";
    FILE   *fp           = NULL;
    BZFILE *bzfp         = NULL;
    int    verbosity     = 0;
    int    smallMode     = 0;
    int    nUnused       = 0;
    __USE(blockSize100k);
    if (mode == NULL) return NULL;
    while (*mode) {
       switch (*mode) {
       case 'r':
          writing = 0; break;
       case 'w':
          writing = 1; break;
       case 's':
          smallMode = 1; break;
       default:
          if (isdigit((unsigned char)(*mode))) {
             blockSize100k = *mode-BZ_HDR_0;
+         }
 @@ -1070,27 +1072,27 @@ const char * BZ_API(BZ2_bzerror) (BZFILE
+{
    int err = ((bzFile *)b)->lastErr;
    if(err>0) err = 0;
    *errnum = err;
    return bzerrorstrings[err*-1];
+}
 #endif
 /*-------------------------------------------------------------*/
 /*--- end                                           bzlib.c ---*/
 /*-------------------------------------------------------------*/
-/*	$NetBSD: bzlib.c,v 1.2 2014/03/05 04:51:37 agc Exp $	*/
+/*	$NetBSD: bzlib.c,v 1.3 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Decompression machinery                               ---*/
 /*---                                          decompress.c ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
 @@ -1716,27 +1718,27 @@ Int32 BZ2_decompress ( DState* s )
    s->save_gSel        = gSel;
    s->save_gMinlen     = gMinlen;
    s->save_gLimit      = gLimit;
    s->save_gBase       = gBase;
    s->save_gPerm       = gPerm;
    return retVal;
+}
 /*-------------------------------------------------------------*/
 /*--- end                                      decompress.c ---*/
 /*-------------------------------------------------------------*/
-/*	$NetBSD: bzlib.c,v 1.2 2014/03/05 04:51:37 agc Exp $	*/
+/*	$NetBSD: bzlib.c,v 1.3 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Table for doing CRCs                                  ---*/
 /*---                                            crctable.c ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
 @@ -1820,27 +1822,27 @@ UInt32 BZ2_crc32Table[256] = {
 xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
 xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
 xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
 x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
 x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
 xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
 xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
 };
 /*-------------------------------------------------------------*/
 /*--- end                                        crctable.c ---*/
 /*-------------------------------------------------------------*/
-/*	$NetBSD: bzlib.c,v 1.2 2014/03/05 04:51:37 agc Exp $	*/
+/*	$NetBSD: bzlib.c,v 1.3 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Huffman coding low-level stuff                        ---*/
 /*---                                             huffman.c ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>

 @@ -1,14 +1,14 @@
-/*	$NetBSD: bzlib_private.h,v 1.1 2013/03/16 07:32:34 agc Exp $	*/
+/*	$NetBSD: bzlib_private.h,v 1.2 2014/12/04 20:08:47 agc Exp $	*/
 /*-------------------------------------------------------------*/
 /*--- Private header file for the library.                  ---*/
 /*---                                       bzlib_private.h ---*/
 /*-------------------------------------------------------------*/
 /* ------------------------------------------------------------------
    This file is part of bzip2/libbzip2, a program and library for
    lossless, block-sorting data compression.
    bzip2/libbzip2 version 1.0.6 of 6 September 2010
    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
 @@ -47,27 +47,27 @@ typedef int             Int32;
 typedef unsigned int    UInt32;
 typedef short           Int16;
 typedef unsigned short  UInt16;
 #define True  ((Bool)1)
 #define False ((Bool)0)
 #ifndef __GNUC__
 #define __inline__  /* */
 #endif
 #ifndef BZ_NO_STDIO
-void BZ2_bz__AssertH__fail ( int errcode );
+void BZ2_bz__AssertH__fail ( int errcode ) __dead;
 #define AssertH(cond,errcode) \
    { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
 #if BZ_DEBUG
 #define AssertD(cond,msg) \
    { if (!(cond)) {       \
       fprintf ( stderr,   \
         "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
       exit(1); \
    }}
 #else
 #define AssertD(cond,msg) /* */
 #endif

 @@ -46,26 +46,34 @@
 #include "b64.h"
 #include "bn.h"
 #include "bufgap.h"
 #include "digest.h"
 #include "misc.h"
 #include "pgpsum.h"
 #include "rsa.h"
 #include "verify.h"
 #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
 #define BITS_TO_BYTES(b)		(((b) + (CHAR_BIT - 1)) / CHAR_BIT)
 /* packet types */
 #define SIGNATURE_PKT			2
 #define ONEPASS_SIGNATURE_PKT		4
 #define PUBKEY_PKT			6
 #define COMPRESSED_DATA_PKT		8
 #define MARKER_PKT			10
 #define LITDATA_PKT			11
 #define TRUST_PKT			12
 #define USERID_PKT			13
 #define PUB_SUBKEY_PKT			14
 #define USER_ATTRIBUTE_PKT		17
 @@ -141,27 +149,27 @@
 #define SIGTYPE_SUBKEY_BINDING		0x18	/* Subkey Binding Signature */
 #define SIGTYPE_PRIMARY_KEY_BINDING	0x19	/* Primary Key Binding Signature */
 #define SIGTYPE_DIRECT_KEY		0x1f	/* Signature directly on a key */
 #define SIGTYPE_KEY_REVOCATION		0x20	/* Key revocation signature */
 #define SIGTYPE_SUBKEY_REVOCATION	0x28	/* Subkey revocation signature */
 #define SIGTYPE_CERT_REVOCATION		0x30	/* Certification revocation signature */
 #define SIGTYPE_TIMESTAMP_SIG		0x40	/* Timestamp signature */
 #define SIGTYPE_3RDPARTY		0x50	/* Third-Party Confirmation signature */
 /* Forward declarations */
 static int read_all_packets(pgpv_t */*pgp*/, pgpv_mem_t */*mem*/, const char */*op*/);
-static int read_binary_file(pgpv_t */*pgp*/, const char */*op*/, const char */*fmt*/, ...);
+static int read_binary_file(pgpv_t */*pgp*/, const char */*op*/, const char */*fmt*/, ...) __printflike(3, 4);
 static int read_binary_memory(pgpv_t */*pgp*/, const char */*op*/, const void */*memory*/, size_t /*size*/);
 /* read a file into the pgpv_mem_t struct */
 static int
 read_file(pgpv_t *pgp, const char *f)
+{
 	struct stat	 st;
 	pgpv_mem_t	*mem;
 	ARRAY_EXPAND(pgp->areas);
 	ARRAY_COUNT(pgp->areas) += 1;
 	mem = &ARRAY_LAST(pgp->areas);
 	memset(mem, 0x0, sizeof(*mem));
 @@ -1984,27 +1992,27 @@ setup_data(pgpv_cursor_t *cursor, pgpv_t
 		/* we have a file name in p */
 		if ((fp = fopen(p, "r")) == NULL) {
 			snprintf(cursor->why, sizeof(cursor->why), "No such file '%s'", (const char *)p);
 			return 0;
+		}
 		if (fgets(buf, (int)sizeof(buf), fp) == NULL) {
 			fclose(fp);
 			snprintf(cursor->why, sizeof(cursor->why), "can't read file '%s'", (const char *)p);
 			return 0;
+		}
 		if (is_armored(buf, sizeof(buf))) {
 			read_ascii_armor_file(cursor, p);
 		} else {
-			read_binary_file(pgp, "signature", "%s", p);
+			read_binary_file(pgp, "signature", "%s", (const char *)p);
+		}
 		fclose(fp);
 	} else {
 		if (is_armored(p, (size_t)size)) {
 			read_ascii_armor_memory(cursor, p, (size_t)size);
 		} else {
 			read_binary_memory(pgp, "signature", p, (size_t)size);
+		}
+	}
 	return 1;
+}
 /* get the data and size from litdata packet */
 @@ -2211,27 +2219,27 @@ static int
 findstr(str_t *array, const char *name)
+{
 	str_t	*sp;
 	for (sp = array ; sp->s ; sp++) {
 		if (strncmp(name, sp->s, sp->len) == 0) {
 			return sp->type;
+		}
+	}
 	return -1;
+}
 /* read public key from the ssh pubkey file */
-static int
+static __printflike(3, 4) int
 read_ssh_file(pgpv_t *pgp, pgpv_primarykey_t *primary, const char *fmt, ...)
+{
 	pgpv_signed_userid_t	 userid;
 	pgpv_pubkey_t		*pubkey;
 	struct stat		 st;
 	bufgap_t		 bg;
 	uint32_t		 len;
 	int64_t			 off;
 	va_list			 args;
 	char			 hostname[256];
 	char			 owner[256];
 	char			*space;
 	char		 	*buf;
 @@ -2579,26 +2587,36 @@ static int
 match_sig_id(pgpv_cursor_t *cursor, pgpv_signature_t *signature, pgpv_litdata_t *litdata, unsigned primary)
+{
 	pgpv_pubkey_t		*pubkey;
 	uint8_t			*data;
 	size_t			 insize;
 	pubkey = &ARRAY_ELEMENT(cursor->pgp->primaries, primary).primary;
 	cursor->sigtime = signature->birth;
 	/* calc hash on data packet */
 	data = get_literal_data(cursor, litdata, &insize);
 	return match_sig(cursor, signature, pubkey, data, insize);
+}
 /* get an element from the found array */
 int
 pgpv_get_cursor_element(pgpv_cursor_t *cursor, size_t element)
+{
 	if (cursor && element < ARRAY_COUNT(cursor->found)) {
 		return (int)ARRAY_ELEMENT(cursor->found, element);
+	}
 	return -1;
+}
 /* verify the signed packets we have */
 size_t
 pgpv_verify(pgpv_cursor_t *cursor, pgpv_t *pgp, const void *p, ssize_t size)
+{
 	pgpv_signature_t	*signature;
 	pgpv_onepass_t		*onepass;
 	pgpv_litdata_t		*litdata;
 	size_t			 pkt;
 	char			 strkeyid[PGPV_STR_KEYID_LEN];
 	int			 j;
 	if (cursor == NULL || pgp == NULL || p == NULL) {
 		return 0;
 @@ -2662,45 +2680,45 @@ pgpv_verify(pgpv_cursor_t *cursor, pgpv_
 	return pkt + 1;
+}
 /* set up the pubkey keyring */
 int
 pgpv_read_pubring(pgpv_t *pgp, const void *keyring, ssize_t size)
+{
 	if (pgp == NULL) {
 		return 0;
+	}
 	if (keyring) {
 		return (size > 0) ?
 			read_binary_memory(pgp, "pubring", keyring, (size_t)size) :
-			read_binary_file(pgp, "pubring", "%s", keyring);
+			read_binary_file(pgp, "pubring", "%s", (const char *)keyring);
+	}
 	return read_binary_file(pgp, "pubring", "%s/%s", nonnull_getenv("HOME"), ".gnupg/pubring.gpg");
+}
 /* set up the pubkey keyring from ssh pub key */
 int
 pgpv_read_ssh_pubkeys(pgpv_t *pgp, const void *keyring, ssize_t size)
+{
 	pgpv_primarykey_t	primary;
 	if (pgp == NULL) {
 		return 0;
+	}
 	if (keyring) {
-		if (!read_ssh_file(pgp, &primary, "%s", keyring)) {
+		if (!read_ssh_file(pgp, &primary, "%s", (const char *)keyring)) {
 			return 0;
+		}
-	} else if (!read_ssh_file(pgp, &primary, "pubring", "%s/%s", nonnull_getenv("HOME"), ".ssh/id_rsa.pub")) {
+	} else if (!read_ssh_file(pgp, &primary, "%s/%s", nonnull_getenv("HOME"), ".ssh/id_rsa.pub")) {
 		return 0;
+	}
 	ARRAY_APPEND(pgp->primaries, primary);
 	pgp->ssh = 1;
 	return 1;
+}
 /* get verified data as a string, return its size */
 size_t
 pgpv_get_verified(pgpv_cursor_t *cursor, size_t cookie, char **ret)
+{
 	pgpv_litdata_t		*litdata;
 	uint8_t			*data;

 @@ -25,28 +25,26 @@
 #include "config.h"
 #include <sys/types.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include "verify.h"
 #include "array.h"
 /* print the time nicely */
 static void
 ptime(int64_t secs)
+{
 	time_t	t;
 	t = (time_t)secs;
 	printf("%s", ctime(&t));
+}
 /* print entry n */
 static void
 pentry(pgpv_t *pgp, int n, const char *modifiers)
 @@ -85,70 +83,70 @@ getstdin(ssize_t *cc, size_t *size)
 	} while (rc > 0);
 	return in;
+}
 /* verify memory or file */
 static int
 verify_data(pgpv_t *pgp, const char *cmd, const char *inname, char *in, ssize_t cc)
+{
 	pgpv_cursor_t	 cursor;
 	const char	*modifiers;
 	size_t		 size;
 	size_t		 cookie;
 	char		*data;
 	int		 el;
 	memset(&cursor, 0x0, sizeof(cursor));
 	if (strcasecmp(cmd, "cat") == 0) {
 		if ((cookie = pgpv_verify(&cursor, pgp, in, cc)) != 0) {
 			if ((size = pgpv_get_verified(&cursor, cookie, &data)) > 0) {
 				write(STDOUT_FILENO, data, size);
+			}
 			return 1;
+		}
 	} else if (strcasecmp(cmd, "verify") == 0 || strcasecmp(cmd, "trust") == 0) {
 		modifiers = (strcasecmp(cmd, "trust") == 0) ? "trust" : NULL;
 		if (pgpv_verify(&cursor, pgp, in, cc)) {
 			printf("Good signature for %s made ", inname);
 			ptime(cursor.sigtime);
-			pentry(pgp, ARRAY_ELEMENT(cursor.found, 0), modifiers);
+			el = pgpv_get_cursor_element(&cursor, 0);
 			pentry(pgp, el, modifiers);
 			return 1;
+		}
 		fprintf(stderr, "Signature did not match contents -- %s\n", cursor.why);
 	} else {
 		fprintf(stderr, "unrecognised command \"%s\"\n", cmd);
+	}
 	return 0;
+}
 int
 main(int argc, char **argv)
+{
 	const char	*modifiers;
 	const char	*keyring;
 	const char	*cmd;
 	ssize_t		 cc;
 	size_t		 size;
 	pgpv_t		 pgp;
 	char		*in;
 	int		 ssh;
 	int		 ok;
 	int		 i;
 	memset(&pgp, 0x0, sizeof(pgp));
 	keyring = NULL;
 	ssh = 0;
 	ok = 1;
 	cmd = "verify";
 	modifiers = NULL;
 	while ((i = getopt(argc, argv, "S:c:k:v")) != -1) {
 		switch(i) {
 		case 'S':
 			ssh = 1;
 			keyring = optarg;
 			break;
 		case 'c':
 			cmd = optarg;
 			break;
 		case 'k':
 			keyring = optarg;
 			break;
 		case 'v':

 @@ -15,27 +15,27 @@
  * 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_	20140304
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20141129"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20141204"
 #include <sys/types.h>
 #include <inttypes.h>
 #ifndef PGPV_ARRAY
 /* creates 2 unsigned vars called "name"c and "name"size in current scope */
 /* also creates an array called "name"s in current scope */
 #define PGPV_ARRAY(type, name)						\
 	unsigned name##c; unsigned name##vsize; type *name##s
 #endif
 /* 64bit key ids */
 @@ -276,21 +276,22 @@ typedef struct pgpv_cursor_t {
 #  else
 #  define __BEGIN_DECLS
 #  define __END_DECLS
 #  endif
 #endif
 __BEGIN_DECLS
 int pgpv_read_pubring(pgpv_t */*pgp*/, const void */*keyringfile/mem*/, ssize_t /*size*/);
 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*/);
 int pgpv_get_cursor_element(pgpv_cursor_t */*cursor*/, size_t /*element*/);
 size_t pgpv_get_entry(pgpv_t */*pgp*/, unsigned /*ent*/, char **/*ret*/, const char */*modifiers*/);
 int pgpv_close(pgpv_t */*pgp*/);
 __END_DECLS
 #endif

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.9 2014/11/29 20:19:46 agc Exp $
+# $NetBSD: Makefile,v 1.10 2014/12/04 20:08:47 agc Exp $
-DISTNAME=		netpgpverify-20141129
+DISTNAME=		netpgpverify-20141204
 CATEGORIES=		security
 MASTER_SITES=		# empty
 DISTFILES=		# empty
 MAINTAINER=		agc@NetBSD.org
 HOMEPAGE=		http://www.NetBSD.org/
 COMMENT=		Standalone PGP and ssh signature verification utility
 LICENSE=		modified-bsd
 AUTO_MKDIRS=		yes
 GNU_CONFIGURE=		yes
 do-extract:

 @@ -1,32 +1,32 @@
-# $NetBSD: Makefile.bsd,v 1.2 2014/02/04 02:11:18 agc Exp $
+# $NetBSD: Makefile.bsd,v 1.3 2014/12/04 20:08:47 agc Exp $
 PROG=netpgpverify
 SRCS= b64.c bignum.c bufgap.c digest.c
 SRCS+= libverify.c main.c misc.c
 SRCS+= pgpsum.c rsa.c
 SRCS+= bzlib.c zlib.c
 SRCS+= md5c.c rmd160.c sha1.c sha2.c tiger.c
 CPPFLAGS+=-I.
 .ifndef PRODUCTION
 CPPFLAGS+=-g -O0
 LDFLAGS+=-g -O0
 .endif
 MAN=	netpgpverify.1
-WARNS=	6
+WARNS=	5
 .include <bsd.prog.mk>
 tst:
 	./${PROG} -k pubring.gpg NetBSD-6.0_RC1_hashes.asc
 	./${PROG} -k pubring.gpg NetBSD-6.0_RC1_hashes.gpg
 	./${PROG} -v
 	./${PROG} -S sshtest-20140202.pub data.gpg
 	./${PROG} -S sshtest-20140202.pub data.sig
 	@echo "expected failure, to check bad signatures fail to verify"
 	-sed -e 's|A|B|' data.gpg | ./${PROG} -S sshtest-20140202.pub

 @@ -55,28 +55,13 @@ netpgp_allocate(size_t n, size_t nels)
 #endif
+}
 void
 netpgp_deallocate(void *ptr, size_t size)
+{
 #ifdef _KERNEL
 	kmem_free(ptr, size);
 #else
 	USE_ARG(size);
 	free(ptr);
 #endif
+}
 #ifndef _KERNEL
 void
 logmessage(const int level, const char *fmt, ...)
 	va_list	args;
 	USE_ARG(level);
 	if (fmt != NULL) {
 		va_start(args, fmt);
 		vfprintf(stderr, fmt, args);
 		va_end(args);
 #endif

 @@ -34,20 +34,16 @@
 #  define __BEGIN_DECLS           extern "C" {
 #  define __END_DECLS             }
 #  else
 #  define __BEGIN_DECLS
 #  define __END_DECLS
 #  endif
 #endif
 __BEGIN_DECLS
 void *netpgp_allocate(size_t /*n*/, size_t /*nels*/);
 void netpgp_deallocate(void */*ptr*/, size_t /*size*/);
 #ifndef _KERNEL
 void logmessage(const int /*level*/, const char */*fmt*/, ...);
 #endif
 __END_DECLS
 #endif