moved files to comply with rest of directory structure of RS

git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-OpenPGP@5260 b45a01b8-16f6-495d-af2f-9b41ad6348cc
2025-05-02 06:06:10 -04:00 · 2012-07-01 13:05:48 +00:00 · 2012-07-01 13:05:48 +00:00 · ba0cca637b
commit ba0cca637b
parent 3b5816e4f8
72 changed files with 78 additions and 103 deletions
--- a/openpgpsdk/src/openpgpsdk/accumulate.c
+++ b/openpgpsdk/src/openpgpsdk/accumulate.c
--- a/openpgpsdk/src/openpgpsdk/accumulate.h
+++ b/openpgpsdk/src/openpgpsdk/accumulate.h
@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_ACCUMULATE_H
+#define OPS_ACCUMULATE_H
+#endif
+
+#include "keyring.h"
+#include "packet-parse.h"
+
+int ops_parse_and_accumulate(ops_keyring_t *keyring,
+			     ops_parse_info_t *parse_info);
--- a/openpgpsdk/src/openpgpsdk/armour.h
+++ b/openpgpsdk/src/openpgpsdk/armour.h
@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_ARMOUR_H__
+#define __OPS_ARMOUR_H__
+
+#include "packet-parse.h"
+#include "signature.h"
+
+unsigned ops_crc24(unsigned checksum,unsigned char c);
+
+void ops_reader_push_dearmour(ops_parse_info_t *parse_info);
+
+void ops_reader_pop_dearmour(ops_parse_info_t *parse_info);
+ops_boolean_t ops_writer_push_clearsigned(ops_create_info_t *info,
+				  ops_create_signature_t *sig);
+void ops_writer_push_armoured_message(ops_create_info_t *info);
+ops_boolean_t ops_writer_switch_to_armoured_signature(ops_create_info_t *info);
+
+typedef enum 
+    {
+    OPS_PGP_MESSAGE=1,
+    OPS_PGP_PUBLIC_KEY_BLOCK,
+    OPS_PGP_PRIVATE_KEY_BLOCK,
+    OPS_PGP_MULTIPART_MESSAGE_PART_X_OF_Y,
+    OPS_PGP_MULTIPART_MESSAGE_PART_X,
+    OPS_PGP_SIGNATURE
+    } ops_armor_type_t;
+
+void ops_writer_push_armoured(ops_create_info_t *info, ops_armor_type_t type);
+
+#define CRC24_INIT 0xb704ceL
+
+#endif /* __OPS_ARMOUR_H__ */
+
+// EOF
--- a/openpgpsdk/src/openpgpsdk/callback.h
+++ b/openpgpsdk/src/openpgpsdk/callback.h
@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_CALLBACK_H__
+#define __OPS_CALLBACK_H__
+
+#define CB(cbinfo,t,pc)	do { (pc)->tag=(t); if(ops_parse_cb((pc),(cbinfo)) == OPS_RELEASE_MEMORY) ops_parser_content_free(pc); } while(0)
+/*#define CB(cbinfo,t,pc)	do { (pc)->tag=(t); if((cbinfo)->cb(pc,(cbinfo)) == OPS_RELEASE_MEMORY) ops_parser_content_free(pc); } while(0)*/
+//#define CB(cbinfo,t,pc)	do { (pc)->tag=(t); if((cbinfo)->cb(pc,(cbinfo)) == OPS_RELEASE_MEMORY) ops_parser_content_free(pc); } while(0)
+
+#define CBP(info,t,pc) CB(&(info)->cbinfo,t,pc)
+
+#define ERR(cbinfo,err,code)	do { content.content.error.error=err; content.tag=OPS_PARSER_ERROR; ops_parse_cb(&content,(cbinfo)); OPS_ERROR(errors,code,err); return -1; } while(0)
+ /*#define ERR(err)	do { content.content.error.error=err; content.tag=OPS_PARSER_ERROR; ops_parse_cb(&content,cbinfo); return -1; } while(0)*/
+
+#define ERRP(info,err)	do { C.error.error=err; CBP(info,OPS_PARSER_ERROR,&content); return ops_false; } while(0)
+
+
+#endif /*__OPS_CALLBACK_H__*/
--- a/openpgpsdk/src/openpgpsdk/compress.c
+++ b/openpgpsdk/src/openpgpsdk/compress.c
--- a/openpgpsdk/src/openpgpsdk/compress.h
+++ b/openpgpsdk/src/openpgpsdk/compress.h
@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#include "packet-parse.h"
+
+int ops_decompress(ops_region_t *region,ops_parse_info_t *parse_info,
+		   ops_compression_type_t type);
+
+ops_boolean_t ops_write_compressed(const unsigned char* data,
+                                   const unsigned int len,
+                                   ops_create_info_t *cinfo);
+
+void ops_writer_push_compressed(ops_create_info_t *cinfo);
--- a/openpgpsdk/src/openpgpsdk/configure.h
+++ b/openpgpsdk/src/openpgpsdk/configure.h
@ -0,0 +1,15 @@
+/* generated by configure from include/openpgpsdk/configure.h.template. Don't edit. */
+
+#define HAVE_ALLOCA_H 0
+#define TIME_T_FMT	"%ld"
+
+/* for silencing unused parameter warnings */
+#define OPS_USED(x)	(x)=(x)
+
+/* for tests, flag to tell gpg not to use blocking randomness */
+#define GNUPG_QUICK_RANDOM "--quick-random"
+
+/* Avoid a bunch of #ifs */
+#ifndef O_BINARY
+# define O_BINARY	0
+#endif
--- a/openpgpsdk/src/openpgpsdk/create.c
+++ b/openpgpsdk/src/openpgpsdk/create.c
--- a/openpgpsdk/src/openpgpsdk/create.h
+++ b/openpgpsdk/src/openpgpsdk/create.h
@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_CREATE_H
+#define OPS_CREATE_H
+
+#include <openpgpsdk/types.h>
+#include <openpgpsdk/packet.h>
+#include <openpgpsdk/crypto.h>
+#include <openpgpsdk/memory.h>
+#include <openpgpsdk/errors.h>
+#include <openpgpsdk/keyring.h>
+#include <openpgpsdk/writer.h>
+
+/**
+ * \ingroup Create
+ * This struct contains the required information about how to write this stream
+ */
+struct ops_create_info
+    {
+    ops_writer_info_t winfo;
+    ops_error_t *errors;	/*!< an error stack */
+    };
+
+void ops_prepare_parent_info(ops_create_info_t *parent_info,
+                             ops_writer_info_t *winfo);
+ops_create_info_t *ops_create_info_new(void);
+void ops_create_info_delete(ops_create_info_t *info);
+
+ops_memory_t* ops_write_mem_from_file(const char *filename, int* errnum);
+int ops_write_file_from_buf(const char *filename, const char* buf, const size_t len, const ops_boolean_t overwrite);
+
+ops_boolean_t ops_calc_session_key_checksum(ops_pk_session_key_t *session_key, unsigned char *cs);
+void ops_build_public_key(ops_memory_t *out,const ops_public_key_t *key,
+			  ops_boolean_t make_packet);
+ops_boolean_t ops_write_struct_user_id(ops_user_id_t *id,
+				       ops_create_info_t *info);
+ops_boolean_t ops_write_struct_public_key(const ops_public_key_t *key,
+					  ops_create_info_t *info);
+
+ops_boolean_t ops_write_ss_header(unsigned length,ops_content_tag_t type,
+				  ops_create_info_t *info);
+ops_boolean_t ops_write_struct_secret_key(const ops_secret_key_t *key,
+                                          const unsigned char* passphrase,
+                                          const size_t pplen,
+					  ops_create_info_t *info);
+ops_boolean_t ops_write_one_pass_sig(const ops_secret_key_t* skey,
+                                     const ops_hash_algorithm_t hash_alg,
+                                     const ops_sig_type_t sig_type,
+                                     ops_create_info_t* info);
+ops_boolean_t ops_write_literal_data_from_buf(const unsigned char *data, 
+                                              const int maxlen, 
+                                              const ops_literal_data_type_t type,
+                                              ops_create_info_t *info);
+ops_pk_session_key_t *ops_create_pk_session_key(const ops_keydata_t *key);
+ops_boolean_t ops_write_pk_session_key(ops_create_info_t *info,
+				       ops_pk_session_key_t *pksk);
+ops_boolean_t ops_write_transferable_public_key(const ops_keydata_t *key, ops_boolean_t armoured, ops_create_info_t *info);
+ops_boolean_t ops_write_transferable_secret_key(const ops_keydata_t *key, const unsigned char* passphrase, const size_t pplen, ops_boolean_t armoured, ops_create_info_t *info);
+
+#endif /*OPS_CREATE_H*/
+
+// eof
--- a/openpgpsdk/src/openpgpsdk/crypto.c
+++ b/openpgpsdk/src/openpgpsdk/crypto.c
--- a/openpgpsdk/src/openpgpsdk/crypto.h
+++ b/openpgpsdk/src/openpgpsdk/crypto.h
@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_CRYPTO_H
+#define OPS_CRYPTO_H
+
+#include "keyring.h"
+#include "util.h"
+#include "packet.h"
+#include "packet-parse.h"
+#include <openssl/dsa.h>
+#include <openssl/opensslv.h>
+#include <openssl/opensslconf.h>
+
+#if OPENSSL_VERSION_NUMBER < 0x00908030L
+# define OPENSSL_NO_CAMELLIA
+#endif
+
+#define OPS_MIN_HASH_SIZE	16
+
+typedef void ops_hash_init_t(ops_hash_t *hash);
+typedef void ops_hash_add_t(ops_hash_t *hash,const unsigned char *data,
+			unsigned length);
+typedef unsigned ops_hash_finish_t(ops_hash_t *hash,unsigned char *out);
+
+/** _ops_hash_t */
+struct _ops_hash_t
+    {
+    ops_hash_algorithm_t algorithm;
+    size_t size;
+    const char *name;
+    ops_hash_init_t *init;
+    ops_hash_add_t *add;
+    ops_hash_finish_t *finish;
+    void *data;
+    };
+
+typedef void ops_crypt_set_iv_t(ops_crypt_t *crypt,
+				const unsigned char *iv);
+typedef void ops_crypt_set_key_t(ops_crypt_t *crypt,
+				 const unsigned char *key);
+typedef void ops_crypt_init_t(ops_crypt_t *crypt);
+typedef void ops_crypt_resync_t(ops_crypt_t *crypt);
+typedef void ops_crypt_block_encrypt_t(ops_crypt_t *crypt,void *out,
+				       const void *in);
+typedef void ops_crypt_block_decrypt_t(ops_crypt_t *crypt,void *out,
+				       const void *in);
+typedef void ops_crypt_cfb_encrypt_t(ops_crypt_t *crypt,void *out,
+                                     const void *in, size_t count);
+typedef void ops_crypt_cfb_decrypt_t(ops_crypt_t *crypt,void *out,
+                                     const void *in, size_t count);
+typedef void ops_crypt_finish_t(ops_crypt_t *crypt);
+
+/** _ops_crypt_t */
+struct _ops_crypt_t
+    {
+    ops_symmetric_algorithm_t algorithm;
+    size_t blocksize;
+    size_t keysize;
+    ops_crypt_set_iv_t *set_iv; /* Call this before decrypt init! */
+    ops_crypt_set_key_t *set_key; /* Call this before init! */
+    ops_crypt_init_t *base_init;
+    ops_crypt_resync_t *decrypt_resync;
+    // encrypt/decrypt one block 
+    ops_crypt_block_encrypt_t *block_encrypt;
+    ops_crypt_block_decrypt_t *block_decrypt;
+
+    // Standard CFB encrypt/decrypt (as used by Sym Enc Int Prot packets)
+    ops_crypt_cfb_encrypt_t *cfb_encrypt;
+    ops_crypt_cfb_decrypt_t *cfb_decrypt;
+
+    ops_crypt_finish_t *decrypt_finish;
+    unsigned char iv[OPS_MAX_BLOCK_SIZE];
+    unsigned char civ[OPS_MAX_BLOCK_SIZE];
+    unsigned char siv[OPS_MAX_BLOCK_SIZE]; /* Needed for weird v3 resync */
+    unsigned char key[OPS_MAX_KEY_SIZE];
+    size_t num; /* Offset - see openssl _encrypt doco */
+    void *encrypt_key;
+    void *decrypt_key;
+    };
+
+void ops_crypto_init(void);
+void ops_crypto_finish(void);
+void ops_hash_md5(ops_hash_t *hash);
+void ops_hash_sha1(ops_hash_t *hash);
+void ops_hash_sha256(ops_hash_t *hash);
+void ops_hash_sha512(ops_hash_t *hash);
+void ops_hash_sha384(ops_hash_t *hash);
+void ops_hash_sha224(ops_hash_t *hash);
+void ops_hash_any(ops_hash_t *hash,ops_hash_algorithm_t alg);
+ops_hash_algorithm_t ops_hash_algorithm_from_text(const char *hash);
+const char *ops_text_from_hash(ops_hash_t *hash);
+unsigned ops_hash_size(ops_hash_algorithm_t alg);
+unsigned ops_hash(unsigned char *out,ops_hash_algorithm_t alg,const void *in,
+		  size_t length);
+
+void ops_hash_add_int(ops_hash_t *hash,unsigned n,unsigned length);
+
+ops_boolean_t ops_dsa_verify(const unsigned char *hash,size_t hash_length,
+			     const ops_dsa_signature_t *sig,
+			     const ops_dsa_public_key_t *dsa);
+int ops_rsa_public_decrypt(unsigned char *out,const unsigned char *in,
+			   size_t length,const ops_rsa_public_key_t *rsa);
+int ops_rsa_public_encrypt(unsigned char *out,const unsigned char *in,
+			   size_t length,const ops_rsa_public_key_t *rsa);
+int ops_rsa_private_encrypt(unsigned char *out,const unsigned char *in,
+			    size_t length,const ops_rsa_secret_key_t *srsa,
+			    const ops_rsa_public_key_t *rsa);
+int ops_rsa_private_decrypt(unsigned char *out,const unsigned char *in,
+			    size_t length,const ops_rsa_secret_key_t *srsa,
+			    const ops_rsa_public_key_t *rsa);
+
+unsigned ops_block_size(ops_symmetric_algorithm_t alg);
+unsigned ops_key_size(ops_symmetric_algorithm_t alg);
+
+int ops_decrypt_data(ops_content_tag_t tag,ops_region_t *region,
+		     ops_parse_info_t *parse_info);
+
+int ops_crypt_any(ops_crypt_t *decrypt,ops_symmetric_algorithm_t alg);
+void ops_decrypt_init(ops_crypt_t *decrypt);
+void ops_encrypt_init(ops_crypt_t *encrypt);
+size_t ops_decrypt_se(ops_crypt_t *decrypt,void *out,const void *in,
+		   size_t count);
+size_t ops_encrypt_se(ops_crypt_t *encrypt,void *out,const void *in,
+		   size_t count);
+size_t ops_decrypt_se_ip(ops_crypt_t *decrypt,void *out,const void *in,
+		   size_t count);
+size_t ops_encrypt_se_ip(ops_crypt_t *encrypt,void *out,const void *in,
+		   size_t count);
+ops_boolean_t ops_is_sa_supported(ops_symmetric_algorithm_t alg);
+
+void ops_reader_push_decrypt(ops_parse_info_t *pinfo,ops_crypt_t *decrypt,
+			     ops_region_t *region);
+void ops_reader_pop_decrypt(ops_parse_info_t *pinfo);
+
+// Hash everything that's read
+void ops_reader_push_hash(ops_parse_info_t *pinfo,ops_hash_t *hash);
+void ops_reader_pop_hash(ops_parse_info_t *pinfo);
+
+int ops_decrypt_and_unencode_mpi(unsigned char *buf,unsigned buflen,const BIGNUM *encmpi,
+		    const ops_secret_key_t *skey);
+ops_boolean_t ops_rsa_encrypt_mpi(const unsigned char *buf, const size_t buflen,
+			      const ops_public_key_t *pkey,
+			      ops_pk_session_key_parameters_t *spk);
+
+
+// Encrypt everything that's written
+struct ops_key_data;
+void ops_writer_push_encrypt(ops_create_info_t *info,
+                             const struct ops_key_data *key);
+
+ops_boolean_t ops_encrypt_file(const char* input_filename, const char* output_filename, const ops_keydata_t *pub_key, const ops_boolean_t use_armour, const ops_boolean_t allow_overwrite);
+ops_boolean_t ops_decrypt_file(const char* input_filename, const char* output_filename, ops_keyring_t *keyring, const ops_boolean_t use_armour, const ops_boolean_t allow_overwrite,ops_parse_cb_t* cb_get_passphrase);
+extern void ops_encrypt_stream(ops_create_info_t* cinfo, const ops_keydata_t* public_key, const ops_secret_key_t* secret_key, const ops_boolean_t compress, const ops_boolean_t use_armour);
+ops_boolean_t ops_decrypt_memory(const unsigned char *encrypted_memory,int em_length, unsigned char **decrypted_memory,int *out_length, ops_keyring_t* keyring, const ops_boolean_t use_armour, ops_parse_cb_t* cb_get_passphrase) ;
+// Keys
+ops_boolean_t ops_rsa_generate_keypair(const int numbits, const unsigned long e, ops_keydata_t* keydata);
+ops_keydata_t* ops_rsa_create_selfsigned_keypair(const int numbits, const unsigned long e, ops_user_id_t * userid);
+
+int ops_dsa_size(const ops_dsa_public_key_t *dsa);
+DSA_SIG* ops_dsa_sign(unsigned char* hashbuf, unsigned hashsize, const ops_dsa_secret_key_t *sdsa, const ops_dsa_public_key_t *dsa);
+#endif
--- a/openpgpsdk/src/openpgpsdk/defs.h
+++ b/openpgpsdk/src/openpgpsdk/defs.h
@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_DEFS_H
+#define OPS_DEFS_H
+
+#define OPS_ARMOURED ops_true
+#define OPS_UNARMOURED ops_false
+
+#define OPS_OVERWRITE_YES ops_true
+#define OPS_OVERWRITE_NO ops_false
+
+#define OPS_ACCUMULATE_YES ops_true
+#define OPS_ACCUMULATE_NO ops_false
+
+#endif /* OPS_DEFS_H */
--- a/openpgpsdk/src/openpgpsdk/errors.c
+++ b/openpgpsdk/src/openpgpsdk/errors.c
--- a/openpgpsdk/src/openpgpsdk/errors.h
+++ b/openpgpsdk/src/openpgpsdk/errors.h
@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_ERRORS
+#define OPS_ERRORS
+
+#include "openpgpsdk/types.h"
+#include <errno.h> 
+
+/** error codes */
+// Remember to add names to map in errors.c
+typedef enum 
+    {
+    OPS_E_OK=0x0000,	/* no error */
+    OPS_E_FAIL=0x0001,	/* general error */
+    OPS_E_SYSTEM_ERROR=0x0002, /* system error, look at errno for details */
+    OPS_E_UNIMPLEMENTED=0x0003, /* feature not yet implemented */
+
+    /* reader errors */
+    OPS_E_R=0x1000,	/* general reader error */
+    OPS_E_R_READ_FAILED		=OPS_E_R+1,
+    OPS_E_R_EARLY_EOF		=OPS_E_R+2,
+    OPS_E_R_BAD_FORMAT		=OPS_E_R+3, // For example, malformed armour
+    OPS_E_R_UNSUPPORTED		=OPS_E_R+4,
+    OPS_E_R_UNCONSUMED_DATA	=OPS_E_R+5,
+
+    /* writer errors */
+    OPS_E_W=0x2000,	/* general writer error */
+    OPS_E_W_WRITE_FAILED = OPS_E_W+1,
+    OPS_E_W_WRITE_TOO_SHORT = OPS_E_W+2,
+
+    /* parser errors */
+    OPS_E_P=0x3000,	/* general parser error */
+    OPS_E_P_NOT_ENOUGH_DATA	=OPS_E_P+1,
+    OPS_E_P_UNKNOWN_TAG		=OPS_E_P+2,
+    OPS_E_P_PACKET_CONSUMED	=OPS_E_P+3,
+    OPS_E_P_MPI_FORMAT_ERROR	=OPS_E_P+4,
+    OPS_E_P_PACKET_NOT_CONSUMED	=OPS_E_P+5,
+    OPS_E_P_DECOMPRESSION_ERROR	=OPS_E_P+6,
+    OPS_E_P_NO_USERID			=OPS_E_P+7,
+
+    /* creator errors */
+    OPS_E_C=0x4000,	/* general creator error */
+
+    /* validation errors */
+    OPS_E_V=0x5000, /* general validation error */
+    OPS_E_V_BAD_SIGNATURE	=OPS_E_V+1,
+    OPS_E_V_NO_SIGNATURE	=OPS_E_V+2,
+    OPS_E_V_UNKNOWN_SIGNER	=OPS_E_V+3,
+    OPS_E_V_BAD_HASH		=OPS_E_V+4,
+
+    /* Algorithm support errors */
+    OPS_E_ALG=0x6000,			/* general algorithm error */
+    OPS_E_ALG_UNSUPPORTED_SYMMETRIC_ALG		=OPS_E_ALG+1,
+    OPS_E_ALG_UNSUPPORTED_PUBLIC_KEY_ALG	=OPS_E_ALG+2,
+    OPS_E_ALG_UNSUPPORTED_SIGNATURE_ALG	=OPS_E_ALG+3,
+    OPS_E_ALG_UNSUPPORTED_HASH_ALG		=OPS_E_ALG+4,
+    OPS_E_ALG_UNSUPPORTED_COMPRESS_ALG		=OPS_E_ALG+5,
+
+    /* Protocol errors */
+    OPS_E_PROTO=0x7000,	/* general protocol error */
+    OPS_E_PROTO_BAD_SYMMETRIC_DECRYPT 	=OPS_E_PROTO+2,
+    OPS_E_PROTO_UNKNOWN_SS		=OPS_E_PROTO+3,
+    OPS_E_PROTO_CRITICAL_SS_IGNORED	=OPS_E_PROTO+4,
+    OPS_E_PROTO_BAD_PUBLIC_KEY_VRSN	=OPS_E_PROTO+5,
+    OPS_E_PROTO_BAD_SIGNATURE_VRSN	=OPS_E_PROTO+6,
+    OPS_E_PROTO_BAD_ONE_PASS_SIG_VRSN	=OPS_E_PROTO+7,
+    OPS_E_PROTO_BAD_PKSK_VRSN		=OPS_E_PROTO+8,
+    OPS_E_PROTO_DECRYPTED_MSG_WRONG_LEN =OPS_E_PROTO+9,
+    OPS_E_PROTO_BAD_SK_CHECKSUM		=OPS_E_PROTO+10,
+    } ops_errcode_t;
+
+/** ops_errcode_name_map_t */
+typedef ops_map_t ops_errcode_name_map_t;
+
+/** one entry in a linked list of errors */
+typedef struct ops_error
+    {
+    ops_errcode_t errcode;
+    int sys_errno; /*!< irrelevent unless errcode == OPS_E_SYSTEM_ERROR */
+    char *comment;
+    const char *file;
+    int line;
+    struct ops_error *next;
+    } ops_error_t;
+
+char *ops_errcode(const ops_errcode_t errcode);
+
+void ops_push_error(ops_error_t **errstack,ops_errcode_t errcode,int sys_errno,
+		const char *file,int line,const char *comment,...);
+void ops_print_error(ops_error_t *err);
+void ops_print_errors(ops_error_t *errstack);
+void ops_free_errors(ops_error_t *errstack);
+int ops_has_error(ops_error_t *errstack, ops_errcode_t errcode);
+void ops_move_errors(ops_create_info_t *source, ops_error_t **errstack);
+
+#define OPS_SYSTEM_ERROR_1(err,code,syscall,fmt,arg)	do { ops_push_error(err,OPS_E_SYSTEM_ERROR,errno,__FILE__,__LINE__,syscall); ops_push_error(err,code,0,__FILE__,__LINE__,fmt,arg); } while(0)
+#define OPS_MEMORY_ERROR(err) {fprintf(stderr, "Memory error\n");} // \todo placeholder for better error handling
+#define OPS_ERROR(err,code,fmt)	do { ops_push_error(err,code,0,__FILE__,__LINE__,fmt); } while(0)
+#define OPS_ERROR_1(err,code,fmt,arg)	do { ops_push_error(err,code,0,__FILE__,__LINE__,fmt,arg); } while(0)
+#define OPS_ERROR_2(err,code,fmt,arg,arg2)	do { ops_push_error(err,code,0,__FILE__,__LINE__,fmt,arg,arg2); } while(0)
+#define OPS_ERROR_3(err,code,fmt,arg,arg2,arg3)	do { ops_push_error(err,code,0,__FILE__,__LINE__,fmt,arg,arg2,arg3); } while(0)
+#define OPS_ERROR_4(err,code,fmt,arg,arg2,arg3,arg4)	do { ops_push_error(err,code,0,__FILE__,__LINE__,fmt,arg,arg2,arg3,arg4); } while(0)
+
+#endif /* OPS_ERRORS */
--- a/openpgpsdk/src/openpgpsdk/final.h
+++ b/openpgpsdk/src/openpgpsdk/final.h
@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* A header that is always included last, for things that need to come last */
+
+#ifdef DMALLOC
+# include <dmalloc.h>
+#endif
+
--- a/openpgpsdk/src/openpgpsdk/fingerprint.c
+++ b/openpgpsdk/src/openpgpsdk/fingerprint.c
--- a/openpgpsdk/src/openpgpsdk/hash.c
+++ b/openpgpsdk/src/openpgpsdk/hash.c
--- a/openpgpsdk/src/openpgpsdk/hash.h
+++ b/openpgpsdk/src/openpgpsdk/hash.h
@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_HASH_H__
+#define __OPS_HASH_H__
+#include "openpgpsdk/packet.h"
+
+void ops_calc_mdc_hash(const unsigned char* preamble, const size_t sz_preamble, const unsigned char* plaintext, const unsigned int sz_plaintext, unsigned char *hashed);
+ops_boolean_t ops_is_hash_alg_supported(const ops_hash_algorithm_t *hash_alg);
+
+#endif /*__OPS_HASH_H__*/
--- a/openpgpsdk/src/openpgpsdk/keyring.c
+++ b/openpgpsdk/src/openpgpsdk/keyring.c
--- a/openpgpsdk/src/openpgpsdk/keyring.h
+++ b/openpgpsdk/src/openpgpsdk/keyring.h
@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_KEYRING_H
+#define OPS_KEYRING_H
+
+#include "packet.h"
+#include "memory.h"
+
+typedef struct ops_keydata ops_keydata_t;
+
+/** \struct ops_keyring_t
+ * A keyring
+ */
+
+typedef struct
+    {
+    int nkeys; // while we are constructing a key, this is the offset
+    int nkeys_allocated;
+    ops_keydata_t *keys;
+    } ops_keyring_t;    
+
+const ops_keydata_t *
+ops_keyring_find_key_by_id(const ops_keyring_t *keyring,
+			   const unsigned char keyid[OPS_KEY_ID_SIZE]);
+const ops_keydata_t *
+ops_keyring_find_key_by_userid(const ops_keyring_t *keyring,
+			       const char* userid);
+void ops_keydata_free(ops_keydata_t *key);
+void ops_keydata_copy(ops_keydata_t *dst,const ops_keydata_t *src);
+void ops_keyring_free(ops_keyring_t *keyring);
+void ops_dump_keyring(const ops_keyring_t *keyring);
+const ops_public_key_t *
+ops_get_public_key_from_data(const ops_keydata_t *data);
+ops_boolean_t ops_is_key_secret(const ops_keydata_t *data);
+const ops_secret_key_t *
+ops_get_secret_key_from_data(const ops_keydata_t *data);
+ops_secret_key_t *
+ops_get_writable_secret_key_from_data(ops_keydata_t *data);
+ops_secret_key_t *ops_decrypt_secret_key_from_data(const ops_keydata_t *key,
+						   const char *pphrase);
+
+ops_boolean_t ops_keyring_read_from_file(ops_keyring_t *keyring, const ops_boolean_t armour, const char *filename);
+ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, const ops_boolean_t armour, ops_memory_t *mem);
+ops_boolean_t ops_write_keyring_to_file(const ops_keyring_t *keyring,ops_boolean_t armoured,const char *filename);
+
+char *ops_malloc_passphrase(char *passphrase);
+char *ops_get_passphrase(void);
+
+void ops_keyring_list(const ops_keyring_t* keyring);
+
+void ops_set_secret_key(ops_parser_content_union_t* content,const ops_keydata_t *key);
+
+const unsigned char* ops_get_key_id(const ops_keydata_t *key);
+unsigned ops_get_user_id_count(const ops_keydata_t *key);
+const unsigned char* ops_get_user_id(const ops_keydata_t *key, unsigned index);
+ops_boolean_t ops_is_key_supported(const ops_keydata_t *key);
+const ops_keydata_t* ops_keyring_get_key_by_index(const ops_keyring_t *keyring, int index);
+
+ops_user_id_t* ops_add_userid_to_keydata(ops_keydata_t* keydata, const ops_user_id_t* userid);
+ops_packet_t* ops_add_packet_to_keydata(ops_keydata_t* keydata, const ops_packet_t* packet);
+void ops_add_signed_userid_to_keydata(ops_keydata_t* keydata, const ops_user_id_t* userid, const ops_packet_t* packet);
+
+ops_boolean_t ops_add_selfsigned_userid_to_keydata(ops_keydata_t* keydata, ops_user_id_t* userid);
+
+ops_keydata_t *ops_keydata_new(void);
+void ops_keydata_init(ops_keydata_t* keydata, const ops_content_tag_t type);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/keyring_local.h
+++ b/openpgpsdk/src/openpgpsdk/keyring_local.h
--- a/openpgpsdk/src/openpgpsdk/lists.c
+++ b/openpgpsdk/src/openpgpsdk/lists.c
--- a/openpgpsdk/src/openpgpsdk/lists.h
+++ b/openpgpsdk/src/openpgpsdk/lists.h
@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_LISTS_H
+#define OPS_LISTS_H
+
+/** ops_ulong_list_t */
+typedef struct
+    {
+    unsigned int size;/* num of array slots allocated */
+    unsigned int used; /* num of array slots currently used */
+    unsigned long *ulongs;
+    } ops_ulong_list_t;
+
+void ops_ulong_list_init(ops_ulong_list_t *list);
+void ops_ulong_list_free(ops_ulong_list_t *list);
+unsigned int ops_ulong_list_add(ops_ulong_list_t *list, unsigned long *ulong);
+
+#endif /* OPS_LISTS_H */
--- a/openpgpsdk/src/openpgpsdk/literal.h
+++ b/openpgpsdk/src/openpgpsdk/literal.h
@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2005-2009 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_LITERAL_H__
+#define __OPS_LITERAL_H__
+
+
+ops_boolean_t write_literal_header(ops_create_info_t *info,
+                                   void *header_data);
+
+void ops_writer_push_literal(ops_create_info_t *info);
+void ops_writer_push_literal_with_opts(ops_create_info_t *info,
+				       unsigned int buf_size);
+
+#endif /* __OPS_LITERAL_H__ */
+
+// EOF
--- a/openpgpsdk/src/openpgpsdk/memory.c
+++ b/openpgpsdk/src/openpgpsdk/memory.c
--- a/openpgpsdk/src/openpgpsdk/memory.h
+++ b/openpgpsdk/src/openpgpsdk/memory.h
@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#include <sys/types.h>
+#include <openssl/bn.h>
+#include "packet.h"
+
+#ifndef OPS_MEMORY_H
+#define OPS_MEMORY_H
+
+/** ops_memory_t
+ */
+typedef struct ops_memory ops_memory_t;
+
+ops_memory_t *ops_memory_new(void);
+void ops_memory_free(ops_memory_t *mem);
+void ops_memory_init(ops_memory_t *mem,size_t initial_size);
+void ops_memory_pad(ops_memory_t *mem,size_t length);
+void ops_memory_add(ops_memory_t *mem,const unsigned char *src,size_t length);
+void ops_memory_place_int(ops_memory_t *mem,unsigned offset,unsigned n,
+			  size_t length);
+void ops_memory_make_packet(ops_memory_t *out,ops_content_tag_t tag);
+void ops_memory_clear(ops_memory_t *mem);
+void ops_memory_release(ops_memory_t *mem);
+
+void ops_writer_set_memory(ops_create_info_t *info,ops_memory_t *mem);
+
+size_t ops_memory_get_length(const ops_memory_t *mem);
+void *ops_memory_get_data(ops_memory_t *mem);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/openssl_crypto.c
+++ b/openpgpsdk/src/openpgpsdk/openssl_crypto.c
--- a/openpgpsdk/src/openpgpsdk/packet-parse.c
+++ b/openpgpsdk/src/openpgpsdk/packet-parse.c
--- a/openpgpsdk/src/openpgpsdk/packet-parse.h
+++ b/openpgpsdk/src/openpgpsdk/packet-parse.h
@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ * Parser for OpenPGP packets - headers.
+ */
+
+#ifndef OPS_PACKET_PARSE_H
+#define OPS_PACKET_PARSE_H
+
+#include "types.h"
+#include "packet.h"
+#include "lists.h"
+
+/** ops_region_t */
+typedef struct ops_region
+    {
+    struct ops_region *parent;
+    unsigned length;
+    unsigned length_read;
+    unsigned last_read; /*!< length of last read, only valid in deepest child */
+    ops_boolean_t indeterminate:1;
+    } ops_region_t;
+
+void ops_init_subregion(ops_region_t *subregion,ops_region_t *region);
+
+#if 0
+/** Return values for reader functions e.g. ops_packet_reader_t() */
+enum ops_reader_ret_t
+    {
+    OPS_R_OK		=0,	/*!< success */
+    OPS_R_EOF		=1,	/*!< reached end of file, no data has been returned */
+    OPS_R_EARLY_EOF	=2,	/*!< could not read the requested
+                                  number of bytes and either
+                                  OPS_RETURN_LENGTH was not set and at
+                                  least 1 byte was read, or there was
+				  an abnormal end to the file (or
+				  armoured block) */
+    OPS_R_PARTIAL_READ	=3,	/*!< if OPS_RETURN_LENGTH is set and
+				  the buffer was not filled */
+    OPS_R_ERROR		=4,	/*!< if there was an error reading */
+    };
+#endif
+
+/** ops_parse_callback_return_t */
+typedef enum
+    {
+    OPS_RELEASE_MEMORY,
+    OPS_KEEP_MEMORY,
+    OPS_FINISHED
+    } ops_parse_cb_return_t;
+
+typedef struct ops_parse_cb_info ops_parse_cb_info_t;
+
+typedef ops_parse_cb_return_t
+ops_parse_cb_t(const ops_parser_content_t *content,
+	       ops_parse_cb_info_t *cbinfo);
+
+typedef struct ops_parse_info ops_parse_info_t;
+typedef struct ops_reader_info ops_reader_info_t;
+typedef struct ops_crypt_info ops_crypt_info_t;
+
+/*
+   A reader MUST read at least one byte if it can, and should read up
+   to the number asked for. Whether it reads more for efficiency is
+   its own decision, but if it is a stacked reader it should never
+   read more than the length of the region it operates in (which it
+   would have to be given when it is stacked).
+
+   If a read is short because of EOF, then it should return the short
+   read (obviously this will be zero on the second attempt, if not the
+   first). Because a reader is not obliged to do a full read, only a
+   zero return can be taken as an indication of EOF.
+
+   If there is an error, then the callback should be notified, the
+   error stacked, and -1 should be returned.
+
+   Note that although length is a size_t, a reader will never be asked
+   to read more than INT_MAX in one go.
+
+ */
+
+typedef int ops_reader_t(void *dest,size_t length,ops_error_t **errors,
+			 ops_reader_info_t *rinfo,ops_parse_cb_info_t *cbinfo);
+
+typedef void ops_reader_destroyer_t(ops_reader_info_t *rinfo);
+
+ops_parse_info_t *ops_parse_info_new(void);
+void ops_parse_info_delete(ops_parse_info_t *pinfo);
+ops_error_t *ops_parse_info_get_errors(ops_parse_info_t *pinfo);
+ops_crypt_t *ops_parse_get_decrypt(ops_parse_info_t *pinfo);
+
+void ops_parse_cb_set(ops_parse_info_t *pinfo,ops_parse_cb_t *cb,void *arg);
+void ops_parse_cb_push(ops_parse_info_t *pinfo,ops_parse_cb_t *cb,void *arg);
+void *ops_parse_cb_get_arg(ops_parse_cb_info_t *cbinfo);
+void *ops_parse_cb_get_errors(ops_parse_cb_info_t *cbinfo);
+void ops_reader_set(ops_parse_info_t *pinfo,ops_reader_t *reader,ops_reader_destroyer_t *destroyer,void *arg);
+void ops_reader_push(ops_parse_info_t *pinfo,ops_reader_t *reader,ops_reader_destroyer_t *destroyer,void *arg);
+void ops_reader_pop(ops_parse_info_t *pinfo);
+void *ops_reader_get_arg_from_pinfo(ops_parse_info_t *pinfo);
+
+void *ops_reader_get_arg(ops_reader_info_t *rinfo);
+
+ops_parse_cb_return_t ops_parse_cb(const ops_parser_content_t *content,
+				   ops_parse_cb_info_t *cbinfo);
+ops_parse_cb_return_t ops_parse_stacked_cb(const ops_parser_content_t *content,
+					   ops_parse_cb_info_t *cbinfo);
+ops_reader_info_t *ops_parse_get_rinfo(ops_parse_info_t *pinfo);
+
+int ops_parse(ops_parse_info_t *parse_info);
+int ops_parse_and_print_errors(ops_parse_info_t *parse_info);
+int ops_parse_and_save_errs(ops_parse_info_t *parse_info,ops_ulong_list_t *errs);
+int ops_parse_errs(ops_parse_info_t *parse_info,ops_ulong_list_t *errs);
+
+void ops_parse_and_validate(ops_parse_info_t *parse_info);
+
+void ops_parse_options(ops_parse_info_t *pinfo,ops_content_tag_t tag,
+		       ops_parse_type_t type);
+
+ops_boolean_t ops_limited_read(unsigned char *dest,size_t length,
+			       ops_region_t *region,ops_error_t **errors,
+			       ops_reader_info_t *rinfo,
+			       ops_parse_cb_info_t *cbinfo);
+ops_boolean_t ops_stacked_limited_read(void *dest,unsigned length,
+				       ops_region_t *region,
+				       ops_error_t **errors,
+				       ops_reader_info_t *rinfo,
+				       ops_parse_cb_info_t *cbinfo);
+void ops_parse_hash_init(ops_parse_info_t *pinfo,ops_hash_algorithm_t type,
+			 const unsigned char *keyid);
+void ops_parse_hash_data(ops_parse_info_t *pinfo,const void *data,
+			 size_t length);
+void ops_parse_hash_finish(ops_parse_info_t *pinfo);
+ops_hash_t *ops_parse_hash_find(ops_parse_info_t *pinfo,
+				const unsigned char keyid[OPS_KEY_ID_SIZE]);
+
+ops_reader_t ops_stacked_read;
+
+/* vim:set textwidth=120: */
+/* vim:set ts=8: */
+
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/packet-print.c
+++ b/openpgpsdk/src/openpgpsdk/packet-print.c
--- a/openpgpsdk/src/openpgpsdk/packet-show-cast.h
+++ b/openpgpsdk/src/openpgpsdk/packet-show-cast.h
@ -0,0 +1,38 @@
+/* Generated from packet-show.cast by ../../util/caster.pl, do not edit. */
+
+#include "types.h"
+
+/* (line 4) char *show_packet_tag(ops_packet_tag_t packet_tag, packet_tag_map_t *packet_tag_map) -> char *ops_str_from_map(int packet_tag, ops_map_t *packet_tag_map) */
+char *ops_str_from_map(int packet_tag, ops_map_t *packet_tag_map);
+#define show_packet_tag(packet_tag,packet_tag_map) ops_str_from_map(CHECKED_INSTANCE_OF(ops_packet_tag_t , packet_tag),CHECKED_INSTANCE_OF( packet_tag_map_t *, packet_tag_map))
+typedef char * show_packet_tag_t(ops_packet_tag_t , packet_tag_map_t *);
+
+/* (line 5) char *show_sig_type(ops_sig_type_t sig_type, sig_type_map_t *sig_type_map) -> char *ops_str_from_map(int sig_type, ops_map_t *sig_type_map) */
+char *ops_str_from_map(int sig_type, ops_map_t *sig_type_map);
+#define show_sig_type(sig_type,sig_type_map) ops_str_from_map(CHECKED_INSTANCE_OF(ops_sig_type_t , sig_type),CHECKED_INSTANCE_OF( sig_type_map_t *, sig_type_map))
+typedef char * show_sig_type_t(ops_sig_type_t , sig_type_map_t *);
+
+/* (line 6) char *show_pka(ops_public_key_algorithm_t pka, public_key_algorithm_map_t *pka_map) -> char *ops_str_from_map(int pka, ops_map_t *pka_map) */
+char *ops_str_from_map(int pka, ops_map_t *pka_map);
+#define show_pka(pka,pka_map) ops_str_from_map(CHECKED_INSTANCE_OF(ops_public_key_algorithm_t , pka),CHECKED_INSTANCE_OF( public_key_algorithm_map_t *, pka_map))
+typedef char * show_pka_t(ops_public_key_algorithm_t , public_key_algorithm_map_t *);
+
+/* (line 7) char *show_ss_type(ops_ss_type_t ss_type, ss_type_map_t *ss_type_map) -> char *ops_str_from_map(int ss_type, ops_map_t *ss_type_map) */
+char *ops_str_from_map(int ss_type, ops_map_t *ss_type_map);
+#define show_ss_type(ss_type,ss_type_map) ops_str_from_map(CHECKED_INSTANCE_OF(ops_ss_type_t , ss_type),CHECKED_INSTANCE_OF( ss_type_map_t *, ss_type_map))
+typedef char * show_ss_type_t(ops_ss_type_t , ss_type_map_t *);
+
+/* (line 8) char *show_ss_rr_code(ops_ss_rr_code_t ss_rr_code, ss_rr_code_map_t *ss_rr_code_map) -> char *ops_str_from_map(int ss_rr_code, ops_map_t *ss_rr_code_map) */
+char *ops_str_from_map(int ss_rr_code, ops_map_t *ss_rr_code_map);
+#define show_ss_rr_code(ss_rr_code,ss_rr_code_map) ops_str_from_map(CHECKED_INSTANCE_OF(ops_ss_rr_code_t , ss_rr_code),CHECKED_INSTANCE_OF( ss_rr_code_map_t *, ss_rr_code_map))
+typedef char * show_ss_rr_code_t(ops_ss_rr_code_t , ss_rr_code_map_t *);
+
+/* (line 9) char *show_hash_algorithm(unsigned char hash,+ops_map_t *hash_algorithm_map) -> char *ops_str_from_map(int hash,ops_map_t *hash_algorithm_map) */
+char *ops_str_from_map(int hash,ops_map_t *hash_algorithm_map);
+#define show_hash_algorithm(hash) ops_str_from_map(CHECKED_INSTANCE_OF(unsigned char , hash),CHECKED_INSTANCE_OF(ops_map_t *, hash_algorithm_map))
+typedef char * show_hash_algorithm_t(unsigned char );
+
+/* (line 10) char *show_symmetric_algorithm(unsigned char hash,+ops_map_t *symmetric_algorithm_map) -> char *ops_str_from_map(int hash,ops_map_t *symmetric_algorithm_map) */
+char *ops_str_from_map(int hash,ops_map_t *symmetric_algorithm_map);
+#define show_symmetric_algorithm(hash) ops_str_from_map(CHECKED_INSTANCE_OF(unsigned char , hash),CHECKED_INSTANCE_OF(ops_map_t *, symmetric_algorithm_map))
+typedef char * show_symmetric_algorithm_t(unsigned char );
--- a/openpgpsdk/src/openpgpsdk/packet-show.c
+++ b/openpgpsdk/src/openpgpsdk/packet-show.c
--- a/openpgpsdk/src/openpgpsdk/packet-show.h
+++ b/openpgpsdk/src/openpgpsdk/packet-show.h
@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file 
+ */
+
+#ifndef OPS_PACKET_TO_TEXT_H
+#define OPS_PACKET_TO_TEXT_H
+
+#ifndef OPS_PACKET_H
+#include "packet.h"
+#endif
+
+/** ops_list_t
+ */
+typedef struct
+    {
+    unsigned int size;/* num of array slots allocated */
+    unsigned int used; /* num of array slots currently used */
+    char **strings;
+    } ops_list_t;
+
+/** ops_text_t
+ */
+typedef struct
+    {
+    ops_list_t known;
+    ops_list_t unknown;
+    } ops_text_t;
+
+/** ops_bit_map_t
+ */
+typedef struct
+    {
+    unsigned char mask;
+    char *string;
+    } ops_bit_map_t;
+
+void ops_text_init(ops_text_t *text);
+void ops_text_free(ops_text_t *text);
+
+const char *ops_show_packet_tag(ops_packet_tag_t packet_tag);
+const char *ops_show_ss_type(ops_ss_type_t ss_type);
+
+const char *ops_show_sig_type(ops_sig_type_t sig_type);
+const char *ops_show_pka(ops_public_key_algorithm_t pka);
+
+ops_text_t *ops_showall_ss_preferred_compression(ops_ss_preferred_compression_t ss_preferred_compression);
+const char *ops_show_ss_preferred_compression(unsigned char octet);
+
+ops_text_t *ops_showall_ss_preferred_hash(ops_ss_preferred_hash_t ss_preferred_hash);
+const char *ops_show_hash_algorithm(unsigned char octet);
+const char *ops_show_symmetric_algorithm(unsigned char hash);
+
+ops_text_t *ops_showall_ss_preferred_ska(ops_ss_preferred_ska_t ss_preferred_ska);
+const char *ops_show_ss_preferred_ska(unsigned char octet);
+
+const char *ops_show_ss_rr_code(ops_ss_rr_code_t ss_rr_code);
+
+ops_text_t *ops_showall_ss_features(ops_ss_features_t ss_features);
+
+ops_text_t *ops_showall_ss_key_flags(ops_ss_key_flags_t ss_key_flags);
+const char *ops_show_ss_key_flag(unsigned char octet, ops_bit_map_t *map);
+
+ops_text_t *ops_showall_ss_key_server_prefs(ops_ss_key_server_prefs_t ss_key_server_prefs);
+const char *ops_show_ss_key_server_prefs(unsigned char octet,
+					 ops_bit_map_t *map);
+
+ops_text_t *ops_showall_ss_notation_data_flags(ops_ss_notation_data_t ss_notation_data);
+
+char *ops_str_from_map(int code, ops_map_t *map);
+
+/* vim:set textwidth=120: */
+/* vim:set ts=8: */
+
+#endif /* OPS_PACKET_TO_TEXT_H */
--- a/openpgpsdk/src/openpgpsdk/packet.h
+++ b/openpgpsdk/src/openpgpsdk/packet.h
@ -0,0 +1,948 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ * packet related headers.
+ */
+
+#ifndef OPS_PACKET_H
+#define OPS_PACKET_H
+
+#include "configure.h"
+
+#include <time.h>
+#include <openssl/bn.h>
+#include <openssl/sha.h>
+#include "types.h"
+#include "errors.h"
+
+/** General-use structure for variable-length data 
+ */
+
+typedef struct
+    {
+    size_t len;
+    unsigned char *contents;
+    } ops_data_t;
+
+/************************************/
+/* Packet Tags - RFC4880, 4.2 */
+/************************************/
+
+/** Packet Tag - Bit 7 Mask (this bit is always set).
+ * The first byte of a packet is the "Packet Tag".  It always
+ * has bit 7 set.  This is the mask for it.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_ALWAYS_SET		0x80
+
+/** Packet Tag - New Format Flag.
+ * Bit 6 of the Packet Tag is the packet format indicator.
+ * If it is set, the new format is used, if cleared the
+ * old format is used.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_NEW_FORMAT		0x40
+
+
+/** Old Packet Format: Mask for content tag.
+ * In the old packet format bits 5 to 2 (including)
+ * are the content tag.  This is the mask to apply
+ * to the packet tag.  Note that you need to
+ * shift by #OPS_PTAG_OF_CONTENT_TAG_SHIFT bits.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_OF_CONTENT_TAG_MASK	0x3c
+/** Old Packet Format: Offset for the content tag.
+ * As described at #OPS_PTAG_OF_CONTENT_TAG_MASK the
+ * content tag needs to be shifted after being masked
+ * out from the Packet Tag.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_OF_CONTENT_TAG_SHIFT	2
+/** Old Packet Format: Mask for length type.
+ * Bits 1 and 0 of the packet tag are the length type
+ * in the old packet format.
+ *
+ * See #ops_ptag_of_lt_t for the meaning of the values.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_OF_LENGTH_TYPE_MASK	0x03
+
+
+/** Old Packet Format Lengths.
+ * Defines the meanings of the 2 bits for length type in the
+ * old packet format.
+ *
+ * \see RFC4880 4.2.1
+ */
+typedef enum
+    {
+    OPS_PTAG_OF_LT_ONE_BYTE		=0x00, /*!< Packet has a 1 byte length - header is 2 bytes long. */ 
+    OPS_PTAG_OF_LT_TWO_BYTE		=0x01, /*!< Packet has a 2 byte length - header is 3 bytes long. */ 
+    OPS_PTAG_OF_LT_FOUR_BYTE		=0x02, /*!< Packet has a 4 byte length - header is 5 bytes long. */ 
+    OPS_PTAG_OF_LT_INDETERMINATE	=0x03  /*!< Packet has a indeterminate length. */ 
+    } ops_ptag_of_lt_t;
+
+
+/** New Packet Format: Mask for content tag.
+ * In the new packet format the 6 rightmost bits
+ * are the content tag.  This is the mask to apply
+ * to the packet tag.  Note that you need to
+ * shift by #OPS_PTAG_NF_CONTENT_TAG_SHIFT bits.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_NF_CONTENT_TAG_MASK	0x3f
+/** New Packet Format: Offset for the content tag.
+ * As described at #OPS_PTAG_NF_CONTENT_TAG_MASK the
+ * content tag needs to be shifted after being masked
+ * out from the Packet Tag.
+ *
+ * \see RFC4880 4.2
+ */
+#define OPS_PTAG_NF_CONTENT_TAG_SHIFT	0
+
+
+/** Structure to hold one parse error string. */
+typedef struct
+    {
+    const char *error; /*!< error message. */
+    } ops_parser_error_t;
+
+/** Structure to hold one error code */
+typedef struct
+    {
+    ops_errcode_t errcode;
+    } ops_parser_errcode_t;
+
+/** Structure to hold one packet tag.
+ * \see RFC4880 4.2
+ */
+typedef struct
+    {
+    unsigned		new_format;	/*!< Whether this packet tag is new (true) or old format (false) */
+    unsigned		content_tag;	/*!< content_tag value - See #ops_content_tag_t for meanings */
+    ops_ptag_of_lt_t	length_type;	/*!< Length type (#ops_ptag_of_lt_t) - only if this packet tag is old format.  Set to 0 if new format. */
+    unsigned		length;		/*!< The length of the packet.  This value is set when we read and compute the
+					  length information, not at the same moment we create the packet tag structure.
+					  Only defined if #length_read is set. */  /* XXX: Ben, is this correct? */
+    unsigned		position;	/*!< The position (within the current reader) of the packet */
+    } ops_ptag_t;
+
+/** Public Key Algorithm Numbers.
+ * OpenPGP assigns a unique Algorithm Number to each algorithm that is part of OpenPGP.
+ *
+ * This lists algorithm numbers for public key algorithms.
+ * 
+ * \see RFC4880 9.1
+ */
+typedef enum
+    {
+    OPS_PKA_RSA			=1,	/*!< RSA (Encrypt or Sign) */
+    OPS_PKA_RSA_ENCRYPT_ONLY	=2,	/*!< RSA Encrypt-Only (deprecated - \see RFC4880 13.5) */
+    OPS_PKA_RSA_SIGN_ONLY	=3,	/*!< RSA Sign-Only (deprecated - \see RFC4880 13.5) */
+    OPS_PKA_ELGAMAL		=16,	/*!< Elgamal (Encrypt-Only) */
+    OPS_PKA_DSA			=17,	/*!< DSA (Digital Signature Algorithm) */
+    OPS_PKA_RESERVED_ELLIPTIC_CURVE	=18,	/*!< Reserved for Elliptic Curve */
+    OPS_PKA_RESERVED_ECDSA		=19,	/*!< Reserved for ECDSA */
+    OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN	=20, 	/*!< Deprecated. */
+    OPS_PKA_RESERVED_DH			=21,	/*!< Reserved for Diffie-Hellman (X9.42, as defined for IETF-S/MIME) */
+    OPS_PKA_PRIVATE00		=100,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE01		=101,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE02		=102,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE03		=103,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE04		=104,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE05		=105,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE06		=106,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE07		=107,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE08		=108,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE09		=109,	/*!< Private/Experimental Algorithm */
+    OPS_PKA_PRIVATE10		=110,	/*!< Private/Experimental Algorithm */
+    } ops_public_key_algorithm_t;
+
+/** Structure to hold one DSA public key parameters.
+ *
+ * \see RFC4880 5.5.2
+ */
+typedef struct
+    {
+    BIGNUM *p;	/*!< DSA prime p */
+    BIGNUM *q;	/*!< DSA group order q */
+    BIGNUM *g;	/*!< DSA group generator g */
+    BIGNUM *y;	/*!< DSA public key value y (= g^x mod p with x being the secret) */
+    } ops_dsa_public_key_t;
+
+/** Structure to hold on RSA public key.
+ *
+ * \see RFC4880 5.5.2
+ */
+typedef struct
+    {
+    BIGNUM *n;	/*!< RSA public modulus n */
+    BIGNUM *e;	/*!< RSA public encryptiong exponent e */
+    } ops_rsa_public_key_t;
+
+/** Structure to hold on ElGamal public key parameters.
+ *
+ * \see RFC4880 5.5.2
+ */
+typedef struct
+    {
+    BIGNUM *p;	/*!< ElGamal prime p */
+    BIGNUM *g;	/*!< ElGamal group generator g */
+    BIGNUM *y;	/*!< ElGamal public key value y (= g^x mod p with x being the secret) */
+    } ops_elgamal_public_key_t;
+
+/** Union to hold public key parameters of any algorithm */
+typedef union
+    {
+    ops_dsa_public_key_t	dsa;		/*!< A DSA public key */
+    ops_rsa_public_key_t	rsa;		/*!< An RSA public key */
+    ops_elgamal_public_key_t	elgamal;	/*!< An ElGamal public key */
+    } ops_public_key_union_t;
+
+/** Version.
+ * OpenPGP has two different protocol versions: version 3 and version 4.
+ *
+ * \see RFC4880 5.2
+ */
+typedef enum
+    {
+    OPS_V2=2,	/*<! Version 2 (essentially the same as v3) */
+    OPS_V3=3,	/*<! Version 3 */
+    OPS_V4=4,	/*<! Version 4 */
+    } ops_version_t;
+
+/** Structure to hold one pgp public key */
+typedef struct
+    {
+    ops_version_t		version;	/*!< version of the key (v3, v4...) */
+    time_t			creation_time;  /*!< when the key was created.  Note that interpretation varies with key
+						  version. */
+    unsigned			days_valid;	/*!< validity period of the key in days since creation.  A value of 0
+						  has a special meaning indicating this key does not expire.  Only
+						  used with v3 keys. */
+    ops_public_key_algorithm_t	algorithm;	/*!< Public Key Algorithm type */
+    ops_public_key_union_t	key;		/*!< Public Key Parameters */
+    } ops_public_key_t;
+
+/** Structure to hold data for one RSA secret key
+ */
+typedef struct
+    {
+    BIGNUM *d;
+    BIGNUM *p;
+    BIGNUM *q;
+    BIGNUM *u;
+    } ops_rsa_secret_key_t;
+
+/** ops_dsa_secret_key_t */
+typedef struct
+    {
+    BIGNUM *x;
+    } ops_dsa_secret_key_t;
+
+/** ops_secret_key_union_t */ 
+typedef struct
+    {
+    ops_rsa_secret_key_t rsa;
+    ops_dsa_secret_key_t dsa;
+    } ops_secret_key_union_t;
+
+/** s2k_usage_t
+ */
+typedef enum
+    {
+    OPS_S2KU_NONE=0,
+    OPS_S2KU_ENCRYPTED_AND_HASHED=254,
+    OPS_S2KU_ENCRYPTED=255,
+    } ops_s2k_usage_t;
+
+/** s2k_specifier_t
+ */
+typedef enum
+    {
+    OPS_S2KS_SIMPLE=0,
+    OPS_S2KS_SALTED=1,
+    OPS_S2KS_ITERATED_AND_SALTED=3
+    } ops_s2k_specifier_t;
+
+/** Symmetric Key Algorithm Numbers.
+ * OpenPGP assigns a unique Algorithm Number to each algorithm that is part of OpenPGP.
+ *
+ * This lists algorithm numbers for symmetric key algorithms.
+ * 
+ * \see RFC4880 9.2
+ */
+typedef enum
+    {
+    OPS_SA_PLAINTEXT	=0, /*!< Plaintext or unencrypted data */
+    OPS_SA_IDEA		=1, /*!< IDEA */
+    OPS_SA_TRIPLEDES	=2, /*!< TripleDES */
+    OPS_SA_CAST5	=3, /*!< CAST5 */
+    OPS_SA_BLOWFISH	=4, /*!< Blowfish */
+    OPS_SA_AES_128	=7, /*!< AES with 128-bit key (AES) */
+    OPS_SA_AES_192	=8, /*!< AES with 192-bit key */
+    OPS_SA_AES_256	=9, /*!< AES with 256-bit key */
+    OPS_SA_TWOFISH	=10, /*!< Twofish with 256-bit key (TWOFISH) */
+    OPS_SA_CAMELLIA_128 =11, /*!< Camellia with 128-bit key */
+    OPS_SA_CAMELLIA_192 =12, /*!< Camellia with 192-bit key */
+    OPS_SA_CAMELLIA_256 =13, /*!< Camellia with 256-bit key */
+    } ops_symmetric_algorithm_t;
+
+/** Hashing Algorithm Numbers.
+ * OpenPGP assigns a unique Algorithm Number to each algorithm that is part of OpenPGP.
+ * 
+ * This lists algorithm numbers for hash algorithms.
+ *
+ * \see RFC4880 9.4
+ */
+typedef enum
+    {
+    OPS_HASH_UNKNOWN	=-1,	/*!< used to indicate errors */
+    OPS_HASH_MD5	= 1,	/*!< MD5 */
+    OPS_HASH_SHA1	= 2,	/*!< SHA-1 */
+    OPS_HASH_RIPEMD	= 3,	/*!< RIPEMD160 */
+
+    OPS_HASH_SHA256	= 8,	/*!< SHA256 */
+    OPS_HASH_SHA384	= 9,	/*!< SHA384 */
+    OPS_HASH_SHA512	=10,	/*!< SHA512 */
+    OPS_HASH_SHA224 = 11,   /*!< SHA224 */
+    } ops_hash_algorithm_t;
+
+// Maximum block size for symmetric crypto
+#define OPS_MAX_BLOCK_SIZE	16
+
+// Maximum key size for symmetric crypto
+#define OPS_MAX_KEY_SIZE	32
+
+// Salt size for hashing
+#define OPS_SALT_SIZE		8
+
+// Hash size for secret key check
+#define OPS_CHECKHASH_SIZE	20
+
+// SHA1 Hash Size \todo is this the same as OPS_CHECKHASH_SIZE??
+#define OPS_SHA1_HASH_SIZE 		SHA_DIGEST_LENGTH
+#define OPS_SHA256_HASH_SIZE	SHA256_DIGEST_LENGTH
+
+// Max hash size
+#define OPS_MAX_HASH_SIZE	64
+
+/** ops_secret_key_t
+ */
+typedef struct
+    {
+    ops_public_key_t		public_key;
+    ops_s2k_usage_t		s2k_usage;
+    ops_s2k_specifier_t		s2k_specifier;
+    ops_symmetric_algorithm_t	algorithm;  // the algorithm used to encrypt
+    					    // the key
+    ops_hash_algorithm_t	hash_algorithm;
+    unsigned char		salt[OPS_SALT_SIZE];
+    unsigned			octet_count;
+    unsigned char		iv[OPS_MAX_BLOCK_SIZE];
+    ops_secret_key_union_t	key;
+    unsigned			checksum;
+    unsigned char		checkhash[OPS_CHECKHASH_SIZE];
+    } ops_secret_key_t;
+
+/** Structure to hold one trust packet's data */
+
+typedef struct
+    {
+    ops_data_t data; /*<! Trust Packet */
+    } ops_trust_t;
+	
+/** Structure to hold one user id */
+typedef struct
+    {
+    unsigned char *user_id;	/*!< User ID - UTF-8 string */
+    } ops_user_id_t;
+
+/** Structure to hold one user attribute */
+typedef struct
+    {
+    ops_data_t data; /*!< User Attribute */
+    } ops_user_attribute_t;
+
+/** Signature Type.
+ * OpenPGP defines different signature types that allow giving different meanings to signatures.  Signature types
+ * include 0x10 for generitc User ID certifications (used when Ben signs Weasel's key), Subkey binding signatures,
+ * document signatures, key revocations, etc.
+ *
+ * Different types are used in different places, and most make only sense in their intended location (for instance a
+ * subkey binding has no place on a UserID).
+ *
+ * \see RFC4880 5.2.1
+ */
+typedef enum
+    {
+    OPS_SIG_BINARY	=0x00,	/*<! Signature of a binary document */
+    OPS_SIG_TEXT	=0x01,	/*<! Signature of a canonical text document */
+    OPS_SIG_STANDALONE	=0x02,	/*<! Standalone signature */
+
+    OPS_CERT_GENERIC	=0x10,	/*<! Generic certification of a User ID and Public Key packet */
+    OPS_CERT_PERSONA	=0x11,	/*<! Persona certification of a User ID and Public Key packet */
+    OPS_CERT_CASUAL	=0x12,	/*<! Casual certification of a User ID and Public Key packet */
+    OPS_CERT_POSITIVE	=0x13,	/*<! Positive certification of a User ID and Public Key packet */
+
+    OPS_SIG_SUBKEY	=0x18,	/*<! Subkey Binding Signature */
+    OPS_SIG_PRIMARY	=0x19,	/*<! Primary Key Binding Signature */
+    OPS_SIG_DIRECT	=0x1f,	/*<! Signature directly on a key */
+
+    OPS_SIG_REV_KEY	=0x20,	/*<! Key revocation signature */
+    OPS_SIG_REV_SUBKEY	=0x28,	/*<! Subkey revocation signature */
+    OPS_SIG_REV_CERT	=0x30,	/*<! Certification revocation signature */
+
+    OPS_SIG_TIMESTAMP	=0x40,	/*<! Timestamp signature */
+
+    OPS_SIG_3RD_PARTY	=0x50,	/*<! Third-Party Confirmation signature */
+    } ops_sig_type_t;
+
+/** Struct to hold parameters of an RSA signature */
+typedef struct
+    {
+    BIGNUM			*sig;	/*!< the signature value (m^d % n) */
+    } ops_rsa_signature_t;
+
+/** Struct to hold parameters of a DSA signature */
+typedef struct
+    {
+    BIGNUM			*r;	/*!< DSA value r */
+    BIGNUM			*s;	/*!< DSA value s */
+    } ops_dsa_signature_t;
+
+/** ops_elgamal_signature_t */
+typedef struct
+    {
+    BIGNUM			*r;
+    BIGNUM			*s;
+    } ops_elgamal_signature_t;
+
+/** Struct to hold data for a private/experimental signature */
+typedef struct
+    {
+    ops_data_t	data;
+    } ops_unknown_signature_t;
+
+/** Union to hold signature parameters of any algorithm */
+typedef union
+    {
+    ops_rsa_signature_t		rsa;	/*!< An RSA Signature */
+    ops_dsa_signature_t		dsa;	/*!< A DSA Signature */
+    ops_elgamal_signature_t	elgamal; /* deprecated */
+    ops_unknown_signature_t 	unknown; /* private or experimental */
+    } ops_signature_union_t;
+
+#define OPS_KEY_ID_SIZE		8
+
+/** Struct to hold a signature packet.
+ *
+ * \see RFC4880 5.2.2
+ * \see RFC4880 5.2.3
+ */
+typedef struct
+    {
+    ops_version_t		version;	/*!< signature version number */
+    ops_sig_type_t		type;		/*!< signature type value */
+    time_t			creation_time;	/*!< creation time of the signature */
+    unsigned char		signer_id[OPS_KEY_ID_SIZE];	/*!< Eight-octet key ID of signer*/
+    ops_public_key_algorithm_t	key_algorithm;	/*!< public key algorithm number */
+    ops_hash_algorithm_t	hash_algorithm;	/*!< hashing algorithm number */
+    ops_signature_union_t	signature;	/*!< signature parameters */
+    size_t			v4_hashed_data_length;
+    unsigned char* 		v4_hashed_data;
+    ops_boolean_t		creation_time_set:1;
+    ops_boolean_t		signer_id_set:1;
+    } ops_signature_info_t;
+
+/** Struct used when parsing a signature */
+typedef struct
+    {
+    ops_signature_info_t	info; /*!< The signature information */
+    /* The following fields are only used while parsing the signature */
+    unsigned char		hash2[2];	/*!< high 2 bytes of hashed value - for quick test */
+    size_t			v4_hashed_data_start; /* only valid if accumulate is set */
+    ops_hash_t			*hash;		/*!< if set, the hash filled in for the data so far */
+    } ops_signature_t;
+
+/** The raw bytes of a signature subpacket */
+
+typedef struct
+    {
+    ops_content_tag_t		tag;
+    size_t			length;
+    unsigned char		*raw;
+    } ops_ss_raw_t;
+
+/** Signature Subpacket : Trust Level */
+
+typedef struct
+    {
+    unsigned char		level;	/*<! Trust Level */
+    unsigned char		amount; /*<! Amount */
+    } ops_ss_trust_t;
+
+/** Signature Subpacket : Revocable */
+typedef struct
+	{
+	ops_boolean_t	revocable;
+	} ops_ss_revocable_t;
+	
+/** Signature Subpacket : Time */
+typedef struct
+    {
+    time_t			time;
+    } ops_ss_time_t;
+
+/** Signature Subpacket : Key ID */
+typedef struct
+    {
+    unsigned char		key_id[OPS_KEY_ID_SIZE];
+    } ops_ss_key_id_t;
+
+/** Signature Subpacket : Notation Data */
+typedef struct
+    {
+    ops_data_t flags;
+    ops_data_t name;
+    ops_data_t value;
+    } ops_ss_notation_data_t;
+
+/** Signature Subpacket : User Defined */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_userdefined_t;
+
+/** Signature Subpacket : Unknown */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_unknown_t;
+
+/** Signature Subpacket : Preferred Symmetric Key Algorithm */
+typedef struct
+    {
+    ops_data_t data;
+    /* Note that value 0 may represent the plaintext algorithm
+       so we cannot expect data->contents to be a null-terminated list */
+    } ops_ss_preferred_ska_t;
+
+/** Signature Subpacket : Preferrred Hash Algorithm */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_preferred_hash_t;
+
+/** Signature Subpacket : Preferred Compression */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_preferred_compression_t;
+
+/** Signature Subpacket : Key Flags */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_key_flags_t;
+
+/** Signature Subpacket : Key Server Preferences */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_key_server_prefs_t;
+
+/** Signature Subpacket : Features */
+typedef struct
+    {
+    ops_data_t data;
+    } ops_ss_features_t;
+
+/** Signature Subpacket : Signature Target */
+typedef struct
+    {
+    ops_public_key_algorithm_t pka_alg;
+    ops_hash_algorithm_t hash_alg;
+    ops_data_t hash;
+    } ops_ss_signature_target_t;
+    
+/** Signature Subpacket : Embedded Signature */
+typedef struct
+    {
+    ops_data_t sig;
+    } ops_ss_embedded_signature_t;
+
+/** ops_packet_t */
+
+typedef struct
+    {
+    size_t			length;
+    unsigned char		*raw;
+    } ops_packet_t;
+
+/** Types of Compression */
+typedef enum
+    {
+    OPS_C_NONE=0,
+    OPS_C_ZIP=1,
+    OPS_C_ZLIB=2,
+    OPS_C_BZIP2=3,
+    } ops_compression_type_t;
+
+/* unlike most structures, this will feed its data as a stream
+ * to the application instead of directly including it */
+/** ops_compressed_t */
+typedef struct
+    {
+    ops_compression_type_t	type;
+    } ops_compressed_t;
+
+/** ops_one_pass_signature_t */
+typedef struct
+    {
+    unsigned char		version;
+    ops_sig_type_t		sig_type;
+    ops_hash_algorithm_t	hash_algorithm;
+    ops_public_key_algorithm_t	key_algorithm;
+    unsigned char		keyid[OPS_KEY_ID_SIZE];
+    ops_boolean_t		nested;
+    } ops_one_pass_signature_t;
+
+/** Signature Subpacket : Primary User ID */
+typedef struct
+    {
+    ops_boolean_t	primary_user_id;
+    } ops_ss_primary_user_id_t;
+
+/** Signature Subpacket : Regexp */
+typedef struct
+    {
+    char *text;
+    } ops_ss_regexp_t;
+
+/** Signature Subpacket : Policy URL */
+typedef struct
+    {
+    char *text;
+    } ops_ss_policy_url_t;
+
+/** Signature Subpacket : Preferred Key Server */
+typedef struct
+    {
+    char *text;
+    } ops_ss_preferred_key_server_t;
+
+/** Signature Subpacket : Revocation Key */
+typedef struct
+    {
+    unsigned char clss;  /* class - name changed for C++ */
+    unsigned char algid;
+    unsigned char fingerprint[20];
+    } ops_ss_revocation_key_t;
+
+/** Signature Subpacket : Revocation Reason */
+typedef struct
+    {
+    unsigned char code;
+    char *text;
+    } ops_ss_revocation_reason_t;
+
+/** literal_data_type_t */
+typedef enum
+    {
+    OPS_LDT_BINARY='b',
+    OPS_LDT_TEXT='t',
+    OPS_LDT_UTF8='u',
+    OPS_LDT_LOCAL='l',
+    OPS_LDT_LOCAL2='1'
+    } ops_literal_data_type_t;
+
+/** ops_literal_data_header_t */
+typedef struct
+    {
+    ops_literal_data_type_t		format;
+    char			filename[256];
+    time_t			modification_time;
+    } ops_literal_data_header_t;
+
+/** ops_literal_data_body_t */
+typedef struct
+    {
+    unsigned			length;
+    unsigned char		*data;//[8192];
+    } ops_literal_data_body_t;
+
+/** ops_mdc_t */
+typedef struct
+    {
+    unsigned char		data[20]; // size of SHA1 hash
+    } ops_mdc_t;
+
+/** ops_armoured_header_value_t */
+typedef struct
+    {
+    char *key;
+    char *value;
+    } ops_armoured_header_value_t;
+
+/** ops_headers_t */
+typedef struct
+    {
+    ops_armoured_header_value_t *headers;
+    unsigned nheaders;
+    } ops_headers_t;
+
+/** ops_armour_header_t */
+typedef struct
+    {
+    const char *type;
+    ops_headers_t headers;
+    } ops_armour_header_t;
+
+/** ops_armour_trailer_t */
+typedef struct
+    {
+    const char *type;
+    } ops_armour_trailer_t;
+
+/** ops_signed_cleartext_header_t */
+typedef struct
+    {
+    ops_headers_t headers;
+    } ops_signed_cleartext_header_t;
+
+/** ops_signed_cleartext_body_t */
+typedef struct
+    {
+    unsigned			length;
+    unsigned char		*data; // \todo fix hard-coded value?
+    } ops_signed_cleartext_body_t;
+
+/** ops_signed_cleartext_trailer_t */
+typedef struct
+    {
+    struct _ops_hash_t		*hash;	/*!< This will not have been finalised, but will have seen all the cleartext data in canonical form */
+    } ops_signed_cleartext_trailer_t;
+
+/** ops_unarmoured_text_t */
+typedef struct
+    {
+    unsigned			length;
+    unsigned char		*data;
+    } ops_unarmoured_text_t;
+
+typedef enum
+    {
+    SE_IP_DATA_VERSION=1
+    } ops_se_ip_data_version_t;
+
+typedef enum
+    {
+    OPS_PKSK_V3=3
+    } ops_pk_session_key_version_t;
+
+/** ops_pk_session_key_parameters_rsa_t */
+typedef struct
+    {
+    BIGNUM			*encrypted_m;
+    BIGNUM			*m;
+    } ops_pk_session_key_parameters_rsa_t;
+
+/** ops_pk_session_key_parameters_elgamal_t */
+typedef struct
+    {
+    BIGNUM			*g_to_k;
+    BIGNUM		        *encrypted_m;
+    } ops_pk_session_key_parameters_elgamal_t;
+
+/** ops_pk_session_key_parameters_t */
+typedef union
+    {
+    ops_pk_session_key_parameters_rsa_t		rsa;
+    ops_pk_session_key_parameters_elgamal_t	elgamal;
+    } ops_pk_session_key_parameters_t;
+
+/** ops_pk_session_key_t */
+typedef struct
+    {
+    ops_pk_session_key_version_t version;
+    unsigned char		key_id[OPS_KEY_ID_SIZE];
+    ops_public_key_algorithm_t	algorithm;
+    ops_pk_session_key_parameters_t parameters;
+    ops_symmetric_algorithm_t	symmetric_algorithm;
+    unsigned char		key[OPS_MAX_KEY_SIZE];
+    unsigned short		checksum;
+    } ops_pk_session_key_t;
+
+/** ops_secret_key_passphrase_t */
+typedef struct
+    {
+    const ops_secret_key_t     *secret_key;
+    char		       **passphrase; /* point somewhere that gets filled in to work around constness of content */
+    } ops_secret_key_passphrase_t;
+
+typedef enum
+    {
+    OPS_SE_IP_V1=1
+    } ops_se_ip_version_t;
+
+/** ops_se_ip_data_header_t */
+typedef struct
+    {
+    ops_se_ip_version_t		version;
+    } ops_se_ip_data_header_t;
+
+/** ops_se_ip_data_body_t */
+typedef struct
+    {
+    unsigned			length;
+    unsigned char*		data; // \todo remember to free this
+    } ops_se_ip_data_body_t;
+
+/** ops_se_data_body_t */
+typedef struct
+    {
+    unsigned			length;
+    unsigned char		data[8192]; // \todo parameterise this!
+    } ops_se_data_body_t;
+
+/** ops_get_secret_key_t */
+typedef struct
+    {
+    const ops_secret_key_t      **secret_key;
+    const ops_pk_session_key_t *pk_session_key;
+    } ops_get_secret_key_t;
+
+/** ops_parser_union_content_t */
+typedef union
+    {
+    ops_parser_error_t		error;
+    ops_parser_errcode_t	errcode;
+    ops_ptag_t			ptag;
+    ops_public_key_t		public_key;
+    ops_trust_t			trust;
+    ops_user_id_t		user_id;
+    ops_user_attribute_t	user_attribute;
+    ops_signature_t		signature;
+    ops_ss_raw_t		ss_raw;
+    ops_ss_trust_t		ss_trust;
+    ops_ss_revocable_t		ss_revocable;
+    ops_ss_time_t		ss_time;
+    ops_ss_key_id_t		ss_issuer_key_id;
+    ops_ss_notation_data_t	ss_notation_data;
+    ops_packet_t		packet;
+    ops_compressed_t		compressed;
+    ops_one_pass_signature_t	one_pass_signature;
+    ops_ss_preferred_ska_t	ss_preferred_ska;
+    ops_ss_preferred_hash_t     ss_preferred_hash;
+    ops_ss_preferred_compression_t     ss_preferred_compression;
+    ops_ss_key_flags_t 		ss_key_flags;
+    ops_ss_key_server_prefs_t	ss_key_server_prefs;
+    ops_ss_primary_user_id_t	ss_primary_user_id;
+    ops_ss_regexp_t		ss_regexp;
+    ops_ss_policy_url_t 	ss_policy_url;
+    ops_ss_preferred_key_server_t	ss_preferred_key_server;
+    ops_ss_revocation_key_t	ss_revocation_key;
+    ops_ss_userdefined_t 	ss_userdefined;
+    ops_ss_unknown_t	 	ss_unknown;
+    ops_literal_data_header_t	literal_data_header;
+    ops_literal_data_body_t	literal_data_body;
+	ops_mdc_t				mdc;
+    ops_ss_features_t		ss_features;
+    ops_ss_signature_target_t ss_signature_target;
+    ops_ss_embedded_signature_t ss_embedded_signature;
+    ops_ss_revocation_reason_t	ss_revocation_reason;
+    ops_secret_key_t		secret_key;
+    ops_user_id_t		ss_signers_user_id;
+    ops_armour_header_t		armour_header;
+    ops_armour_trailer_t	armour_trailer;
+    ops_signed_cleartext_header_t signed_cleartext_header;
+    ops_signed_cleartext_body_t	signed_cleartext_body;
+    ops_signed_cleartext_trailer_t signed_cleartext_trailer;
+    ops_unarmoured_text_t	unarmoured_text;
+    ops_pk_session_key_t	pk_session_key;
+    ops_secret_key_passphrase_t	secret_key_passphrase;
+    ops_se_ip_data_header_t	se_ip_data_header;
+    ops_se_ip_data_body_t	se_ip_data_body;
+    ops_se_data_body_t		se_data_body;
+    ops_get_secret_key_t	get_secret_key;
+    } ops_parser_content_union_t;
+
+/** ops_parser_content_t */
+struct ops_parser_content_t
+    {
+    ops_content_tag_t		tag;
+    unsigned char		critical; /* for signature subpackets */
+    ops_parser_content_union_t 	content;
+    };
+
+/** ops_fingerprint_t */
+typedef struct
+    {
+    unsigned char 		fingerprint[20];
+    unsigned			length;
+    } ops_fingerprint_t;
+
+void ops_init(void);
+void ops_finish(void);
+void ops_keyid(unsigned char keyid[OPS_KEY_ID_SIZE],
+	       const ops_public_key_t *key);
+void ops_fingerprint(ops_fingerprint_t *fp,const ops_public_key_t *key);
+void ops_public_key_free(ops_public_key_t *key);
+void ops_public_key_copy(ops_public_key_t *dst,const ops_public_key_t *src);
+void ops_user_id_free(ops_user_id_t *id);
+void ops_user_attribute_free(ops_user_attribute_t *att);
+void ops_signature_free(ops_signature_t *sig);
+void ops_trust_free(ops_trust_t *trust);
+void ops_ss_preferred_ska_free(ops_ss_preferred_ska_t *ss_preferred_ska);
+void ops_ss_preferred_hash_free(ops_ss_preferred_hash_t *ss_preferred_hash);
+void ops_ss_preferred_compression_free(ops_ss_preferred_compression_t *ss_preferred_compression);
+void ops_ss_key_flags_free(ops_ss_key_flags_t *ss_key_flags);
+void ops_ss_key_server_prefs_free(ops_ss_key_server_prefs_t *ss_key_server_prefs);
+void ops_ss_features_free(ops_ss_features_t *ss_features);
+void ops_ss_notation_data_free(ops_ss_notation_data_t *ss_notation_data);
+void ops_ss_policy_url_free(ops_ss_policy_url_t *ss_policy_url);
+void ops_ss_preferred_key_server_free(ops_ss_preferred_key_server_t *ss_preferred_key_server);
+void ops_ss_regexp_free(ops_ss_regexp_t *ss_regexp);
+void ops_ss_userdefined_free(ops_ss_userdefined_t *ss_userdefined);
+void ops_ss_reserved_free(ops_ss_unknown_t *ss_unknown);
+void ops_ss_revocation_reason_free(ops_ss_revocation_reason_t *ss_revocation_reason);
+void ops_ss_signature_target_free(ops_ss_signature_target_t *ss_signature_target);
+void ops_ss_embedded_signature_free(ops_ss_embedded_signature_t *ss_embedded_signature);
+
+void ops_packet_free(ops_packet_t *packet);
+void ops_parser_content_free(ops_parser_content_t *c);
+void ops_secret_key_free(ops_secret_key_t *key);
+void ops_secret_key_copy(ops_secret_key_t *dst,const ops_secret_key_t *src);
+void ops_pk_session_key_free(ops_pk_session_key_t *sk);
+
+/* vim:set textwidth=120: */
+/* vim:set ts=8: */
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/parse_local.h
+++ b/openpgpsdk/src/openpgpsdk/parse_local.h
--- a/openpgpsdk/src/openpgpsdk/partial.h
+++ b/openpgpsdk/src/openpgpsdk/partial.h
@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2005-2009 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer, Alasdair Mackintosh.
+ * The Contributors have asserted their moral rights under the
+ * UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_PARTIAL_H__
+#define __OPS_PARTIAL_H__
+
+#include "types.h"
+#include "writer.h"
+
+/**
+ * Function that writes out a packet header. See
+ * ops_writer_push_partial
+ */
+typedef ops_boolean_t ops_write_partial_header_t(ops_create_info_t *info,
+                                                 void *data);
+
+typedef ops_boolean_t ops_write_partial_trailer_t(ops_create_info_t *info,
+                                                  void *data);
+
+void ops_writer_push_partial(size_t packet_size,
+                             ops_create_info_t *info,
+                             ops_content_tag_t tag,
+                             ops_write_partial_header_t *header_writer,
+                             void *header_data);
+
+void ops_writer_push_partial_with_trailer(
+    size_t packet_size,
+    ops_create_info_t *cinfo,
+    ops_content_tag_t tag,
+    ops_write_partial_header_t *header_writer,
+    void *header_data,
+    ops_write_partial_trailer_t *trailer_writer,
+    void *trailer_data);
+
+#endif /* __OPS_PARTIAL_H__ */
--- a/openpgpsdk/src/openpgpsdk/random.c
+++ b/openpgpsdk/src/openpgpsdk/random.c
--- a/openpgpsdk/src/openpgpsdk/random.h
+++ b/openpgpsdk/src/openpgpsdk/random.h
@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef WIN32
+#include <malloc.h>
+#else
+#include <unistd.h>
+#endif
+
+void ops_random(void *dest,size_t length);
--- a/openpgpsdk/src/openpgpsdk/reader.c
+++ b/openpgpsdk/src/openpgpsdk/reader.c
--- a/openpgpsdk/src/openpgpsdk/reader_armoured.c
+++ b/openpgpsdk/src/openpgpsdk/reader_armoured.c
--- a/openpgpsdk/src/openpgpsdk/reader_encrypted_se.c
+++ b/openpgpsdk/src/openpgpsdk/reader_encrypted_se.c
--- a/openpgpsdk/src/openpgpsdk/reader_encrypted_seip.c
+++ b/openpgpsdk/src/openpgpsdk/reader_encrypted_seip.c
--- a/openpgpsdk/src/openpgpsdk/reader_fd.c
+++ b/openpgpsdk/src/openpgpsdk/reader_fd.c
--- a/openpgpsdk/src/openpgpsdk/reader_hashed.c
+++ b/openpgpsdk/src/openpgpsdk/reader_hashed.c
--- a/openpgpsdk/src/openpgpsdk/reader_mem.c
+++ b/openpgpsdk/src/openpgpsdk/reader_mem.c
--- a/openpgpsdk/src/openpgpsdk/readerwriter.c
+++ b/openpgpsdk/src/openpgpsdk/readerwriter.c
--- a/openpgpsdk/src/openpgpsdk/readerwriter.h
+++ b/openpgpsdk/src/openpgpsdk/readerwriter.h
@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_READERWRITER_H__
+#define __OPS_READERWRITER_H__
+
+#include <openpgpsdk/memory.h>
+#include <openpgpsdk/create.h>
+
+
+void ops_reader_set_fd(ops_parse_info_t *pinfo,int fd);
+void ops_reader_set_memory(ops_parse_info_t *pinfo,const void *buffer,
+			   size_t length);
+
+// Do a sum mod 65536 of all bytes read (as needed for secret keys)
+void ops_reader_push_sum16(ops_parse_info_t *pinfo);
+unsigned short ops_reader_pop_sum16(ops_parse_info_t *pinfo);
+
+void ops_reader_push_se_ip_data(ops_parse_info_t *pinfo, ops_crypt_t *decrypt,
+                                ops_region_t *region);
+void ops_reader_pop_se_ip_data(ops_parse_info_t* pinfo);
+
+//
+ops_boolean_t ops_write_mdc(const unsigned char *hashed,
+                                   ops_create_info_t* info);
+ops_boolean_t ops_write_se_ip_pktset(const unsigned char *data,
+                                            const unsigned int len,
+                                            ops_crypt_t *crypt,
+                                            ops_create_info_t *info);
+void ops_writer_push_encrypt_crypt(ops_create_info_t *cinfo,
+                                   ops_crypt_t *crypt);
+void ops_writer_push_encrypt_se_ip(ops_create_info_t *cinfo,
+                                   const ops_keydata_t *pub_key);
+// Secret Key checksum
+
+void ops_push_skey_checksum_writer(ops_create_info_t *cinfo, ops_secret_key_t *skey);
+ops_boolean_t ops_pop_skey_checksum_writer(ops_create_info_t *cinfo);
+
+
+// memory writing
+void ops_setup_memory_write(ops_create_info_t **cinfo, ops_memory_t **mem, size_t bufsz);
+void ops_teardown_memory_write(ops_create_info_t *cinfo, ops_memory_t *mem);
+
+// memory reading
+void ops_setup_memory_read(ops_parse_info_t **pinfo, ops_memory_t *mem,
+                           void* arg,
+                           ops_parse_cb_return_t callback(const ops_parser_content_t *, ops_parse_cb_info_t *),ops_boolean_t accumulate);
+void ops_teardown_memory_read(ops_parse_info_t *pinfo, ops_memory_t *mem);
+
+// file writing
+int ops_setup_file_write(ops_create_info_t **cinfo, const char* filename, ops_boolean_t allow_overwrite);
+void ops_teardown_file_write(ops_create_info_t *cinfo, int fd);
+
+// file appending
+int ops_setup_file_append(ops_create_info_t **cinfo, const char* filename);
+void ops_teardown_file_append(ops_create_info_t *cinfo, int fd);
+
+// file reading
+int ops_setup_file_read(ops_parse_info_t **pinfo, const char *filename, void* arg,
+                        ops_parse_cb_return_t callback(const ops_parser_content_t *, ops_parse_cb_info_t *), ops_boolean_t accumulate);
+void ops_teardown_file_read(ops_parse_info_t *pinfo, int fd);
+
+ops_boolean_t ops_reader_set_accumulate(ops_parse_info_t* pinfo, ops_boolean_t state);
+
+// useful callbacks
+ops_parse_cb_return_t
+callback_literal_data(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);
+ops_parse_cb_return_t
+callback_pk_session_key(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);
+ops_parse_cb_return_t
+callback_cmd_get_secret_key(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);
+ops_parse_cb_return_t
+callback_cmd_get_passphrase_from_cmdline(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);
+
+#endif /*OPS_READERWRITER_H__*/
--- a/openpgpsdk/src/openpgpsdk/signature.c
+++ b/openpgpsdk/src/openpgpsdk/signature.c
--- a/openpgpsdk/src/openpgpsdk/signature.h
+++ b/openpgpsdk/src/openpgpsdk/signature.h
@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_SIGNATURE_H
+#define OPS_SIGNATURE_H
+
+#include "packet.h"
+#include "util.h"
+#include "create.h"
+
+typedef struct ops_create_signature ops_create_signature_t;
+
+ops_create_signature_t *ops_create_signature_new(void);
+void ops_create_signature_delete(ops_create_signature_t *sig);
+
+ops_boolean_t
+ops_check_user_id_certification_signature(const ops_public_key_t *key,
+					  const ops_user_id_t *id,
+					  const ops_signature_t *sig,
+					  const ops_public_key_t *signer,
+					  const unsigned char *raw_packet);
+ops_boolean_t
+ops_check_user_attribute_certification_signature(const ops_public_key_t *key,
+						 const ops_user_attribute_t *attribute,
+						 const ops_signature_t *sig,
+						 const ops_public_key_t *signer,
+						 const unsigned char *raw_packet);
+ops_boolean_t
+ops_check_subkey_signature(const ops_public_key_t *key,
+			   const ops_public_key_t *subkey,
+			   const ops_signature_t *sig,
+			   const ops_public_key_t *signer,
+			   const unsigned char *raw_packet);
+ops_boolean_t
+ops_check_direct_signature(const ops_public_key_t *key,
+			   const ops_signature_t *sig,
+			   const ops_public_key_t *signer,
+			   const unsigned char *raw_packet);
+ops_boolean_t
+ops_check_hash_signature(ops_hash_t *hash,
+			 const ops_signature_t *sig,
+			 const ops_public_key_t *signer);
+void ops_signature_start_key_signature(ops_create_signature_t *sig,
+				       const ops_public_key_t *key,
+				       const ops_user_id_t *id,
+				       ops_sig_type_t type);
+void ops_signature_start_cleartext_signature(ops_create_signature_t *sig,
+					     const ops_secret_key_t *key,
+					     const ops_hash_algorithm_t hash,
+					     const ops_sig_type_t type);
+void ops_signature_start_message_signature(ops_create_signature_t *sig,
+					     const ops_secret_key_t *key,
+					     const ops_hash_algorithm_t hash,
+					     const ops_sig_type_t type);
+
+void ops_signature_add_data(ops_create_signature_t *sig,const void *buf,
+			    size_t length);
+ops_hash_t *ops_signature_get_hash(ops_create_signature_t *sig);
+ops_boolean_t ops_signature_hashed_subpackets_end(ops_create_signature_t *sig);
+ops_boolean_t ops_write_signature(ops_create_signature_t *sig,const ops_public_key_t *key,
+			 const ops_secret_key_t *skey, ops_create_info_t *opt);
+ops_boolean_t ops_signature_add_creation_time(ops_create_signature_t *sig,time_t when);
+ops_boolean_t ops_signature_add_issuer_key_id(ops_create_signature_t *sig,
+				     const unsigned char keyid[OPS_KEY_ID_SIZE]);
+void ops_signature_add_primary_user_id(ops_create_signature_t *sig,
+				       ops_boolean_t primary);
+
+// Standard Interface
+ops_boolean_t ops_sign_file_as_cleartext(const char* input_filename, const char* output_filename, const ops_secret_key_t *skey, const ops_boolean_t overwrite);
+ops_boolean_t ops_sign_buf_as_cleartext(const char* input, const size_t len, ops_memory_t** output, const ops_secret_key_t *skey);
+ops_boolean_t ops_sign_file(const char* input_filename, const char* output_filename, const ops_secret_key_t *skey, const ops_boolean_t use_armour, const ops_boolean_t overwrite);
+ops_memory_t * ops_sign_buf(const void* input, const size_t input_len, const ops_sig_type_t sig_type,  const ops_secret_key_t *skey, const ops_boolean_t use_armour,ops_boolean_t include_data);
+ops_boolean_t ops_writer_push_signed(ops_create_info_t *cinfo, const ops_sig_type_t sig_type, const ops_secret_key_t *skey);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/std_print.h
+++ b/openpgpsdk/src/openpgpsdk/std_print.h
@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_STD_PRINT_H
+#define OPS_STD_PRINT_H
+
+#include "openpgpsdk/packet.h"
+#include "openpgpsdk/packet-parse.h"
+#include "openpgpsdk/keyring.h"
+
+void print_bn( const char *name, 
+		      const BIGNUM *bn);
+void ops_print_pk_session_key(ops_content_tag_t tag,
+                          const ops_pk_session_key_t *key);
+void ops_print_public_keydata(const ops_keydata_t *key);
+
+void ops_print_public_keydata_verbose(const ops_keydata_t *key);
+void ops_print_public_key(const ops_public_key_t *pkey);
+
+void ops_print_secret_keydata(const ops_keydata_t *key);
+void ops_print_secret_keydata_verbose(const ops_keydata_t *key);
+//void ops_print_secret_key(const ops_content_tag_t type, const ops_secret_key_t* skey);
+int ops_print_packet(const ops_parser_content_t *content_);
+void ops_list_packets(char *filename, ops_boolean_t armour, ops_keyring_t* pubring, ops_parse_cb_t* cb_get_passphrase);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/streamwriter.h
+++ b/openpgpsdk/src/openpgpsdk/streamwriter.h
@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OPS_STREAMWRITER_H__
+#define __OPS_STREAMWRITER_H__
+
+#include <openpgpsdk/readerwriter.h>
+
+void ops_writer_push_stream_encrypt_se_ip(ops_create_info_t *cinfo,
+                                          const ops_keydata_t *pub_key);
+
+#endif /*__OPS_STREAMWRITER_H__*/
--- a/openpgpsdk/src/openpgpsdk/symmetric.c
+++ b/openpgpsdk/src/openpgpsdk/symmetric.c
--- a/openpgpsdk/src/openpgpsdk/types.h
+++ b/openpgpsdk/src/openpgpsdk/types.h
@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_TYPES_H
+#define OPS_TYPES_H
+
+/** Special type for intermediate function casting, avoids warnings on
+    some platforms
+*/
+typedef void (*ops_void_fptr)(void);
+#define ops_fcast(f) ((ops_void_fptr)f)
+
+/** ops_map_t
+ */
+typedef struct 
+    {
+    int type;
+    char *string;
+    } ops_map_t;
+
+/** Boolean type */
+typedef unsigned ops_boolean_t;
+
+/** ops_content_tag_t */
+
+/* PTag Content Tags */
+/***************************/
+
+/** Package Tags (aka Content Tags) and signature subpacket types.
+ * This enumerates all rfc-defined packet tag values and the
+ * signature subpacket type values that we understand.
+ *
+ * \see RFC4880 4.3
+ * \see RFC4880 5.2.3.1
+ */
+
+#ifndef __cplusplus
+typedef enum ops_content_tag_t ops_content_tag_t ;
+#endif
+
+enum ops_content_tag_t
+    {
+    OPS_PTAG_CT_RESERVED		= 0,	/*!< Reserved - a packet tag must not have this value */
+    OPS_PTAG_CT_PK_SESSION_KEY		= 1,	/*!< Public-Key Encrypted Session Key Packet */
+    OPS_PTAG_CT_SIGNATURE		= 2,	/*!< Signature Packet */
+    OPS_PTAG_CT_SK_SESSION_KEY		= 3,	/*!< Symmetric-Key Encrypted Session Key Packet */
+    OPS_PTAG_CT_ONE_PASS_SIGNATURE	= 4,	/*!< One-Pass Signature Packet */
+    OPS_PTAG_CT_SECRET_KEY		= 5,	/*!< Secret Key Packet */
+    OPS_PTAG_CT_PUBLIC_KEY		= 6,	/*!< Public Key Packet */
+    OPS_PTAG_CT_SECRET_SUBKEY		= 7,	/*!< Secret Subkey Packet */
+    OPS_PTAG_CT_COMPRESSED		= 8,	/*!< Compressed Data Packet */
+    OPS_PTAG_CT_SE_DATA			= 9,	/*!< Symmetrically Encrypted Data Packet */
+    OPS_PTAG_CT_MARKER			=10,	/*!< Marker Packet */
+    OPS_PTAG_CT_LITERAL_DATA		=11,	/*!< Literal Data Packet */
+    OPS_PTAG_CT_TRUST			=12,	/*!< Trust Packet */
+    OPS_PTAG_CT_USER_ID			=13,	/*!< User ID Packet */
+    OPS_PTAG_CT_PUBLIC_SUBKEY		=14,	/*!< Public Subkey Packet */
+    OPS_PTAG_CT_RESERVED2		=15,	/*!< reserved */
+    OPS_PTAG_CT_RESERVED3		=16,	/*!< reserved */
+    OPS_PTAG_CT_USER_ATTRIBUTE		=17,	/*!< User Attribute Packet */
+    OPS_PTAG_CT_SE_IP_DATA		=18,	/*!< Sym. Encrypted and Integrity Protected Data Packet */
+    OPS_PTAG_CT_MDC			=19,	/*!< Modification Detection Code Packet */
+
+    OPS_PARSER_PTAG			=0x100,	/*!< Internal Use: The packet is the "Packet Tag" itself - used when
+						     callback sends back the PTag. */
+    OPS_PTAG_RAW_SS			=0x101,	/*!< Internal Use: content is raw sig subtag */
+    OPS_PTAG_SS_ALL			=0x102,	/*!< Internal Use: select all subtags */
+    OPS_PARSER_PACKET_END		=0x103,
+
+    /* signature subpackets (0x200-2ff) (type+0x200) */
+    /* only those we can parse are listed here */
+    OPS_PTAG_SIGNATURE_SUBPACKET_BASE	=0x200,		/*!< Base for signature subpacket types - All signature type
+							     values are relative to this value. */
+    OPS_PTAG_SS_CREATION_TIME		=0x200+2,	/*!< signature creation time */
+    OPS_PTAG_SS_EXPIRATION_TIME		=0x200+3,	/*!< signature expiration time */
+
+    OPS_PTAG_SS_EXPORTABLE_CERTIFICATION =0x200+4, /*!< exportable certification */
+    OPS_PTAG_SS_TRUST			=0x200+5,	/*!< trust signature */
+    OPS_PTAG_SS_REGEXP			=0x200+6,	/*!< regular expression */
+    OPS_PTAG_SS_REVOCABLE		=0x200+7,	/*!< revocable */
+    OPS_PTAG_SS_KEY_EXPIRATION_TIME	=0x200+9,	/*!< key expiration time */
+    OPS_PTAG_SS_RESERVED		=0x200+10,	/*!< reserved */
+    OPS_PTAG_SS_PREFERRED_SKA 		=0x200+11,	/*!< preferred symmetric algorithms */
+    OPS_PTAG_SS_REVOCATION_KEY 		=0x200+12,	/*!< revocation key */
+    OPS_PTAG_SS_ISSUER_KEY_ID		=0x200+16, /*!< issuer key ID */
+    OPS_PTAG_SS_NOTATION_DATA		=0x200+20, /*!< notation data */
+    OPS_PTAG_SS_PREFERRED_HASH          =0x200+21, /*!< preferred hash algorithms */
+    OPS_PTAG_SS_PREFERRED_COMPRESSION	=0x200+22, /*!< preferred compression algorithms */
+    OPS_PTAG_SS_KEY_SERVER_PREFS	=0x200+23, /*!< key server preferences */
+    OPS_PTAG_SS_PREFERRED_KEY_SERVER	=0x200+24, /*!< Preferred Key Server */
+    OPS_PTAG_SS_PRIMARY_USER_ID		=0x200+25, /*!< primary User ID */
+    OPS_PTAG_SS_POLICY_URI		=0x200+26, /*!< Policy URI */
+    OPS_PTAG_SS_KEY_FLAGS 		=0x200+27, /*!< key flags */
+    OPS_PTAG_SS_SIGNERS_USER_ID		=0x200+28, /*!< Signer's User ID */
+    OPS_PTAG_SS_REVOCATION_REASON	=0x200+29, /*!< reason for revocation */
+    OPS_PTAG_SS_FEATURES		=0x200+30, /*!< features */
+    OPS_PTAG_SS_SIGNATURE_TARGET =0x200+31, /*!< signature target */
+    OPS_PTAG_SS_EMBEDDED_SIGNATURE=0x200+32, /*!< embedded signature */
+
+    OPS_PTAG_SS_USERDEFINED00	=0x200+100, /*!< internal or user-defined */
+    OPS_PTAG_SS_USERDEFINED01	=0x200+101, 
+    OPS_PTAG_SS_USERDEFINED02	=0x200+102,
+    OPS_PTAG_SS_USERDEFINED03	=0x200+103,
+    OPS_PTAG_SS_USERDEFINED04	=0x200+104,
+    OPS_PTAG_SS_USERDEFINED05	=0x200+105,
+    OPS_PTAG_SS_USERDEFINED06	=0x200+106,
+    OPS_PTAG_SS_USERDEFINED07	=0x200+107,
+    OPS_PTAG_SS_USERDEFINED08	=0x200+108,
+    OPS_PTAG_SS_USERDEFINED09	=0x200+109,
+    OPS_PTAG_SS_USERDEFINED10	=0x200+110,
+
+	
+    /* pseudo content types */
+    OPS_PTAG_CT_LITERAL_DATA_HEADER	=0x300,
+    OPS_PTAG_CT_LITERAL_DATA_BODY	=0x300+1,
+    OPS_PTAG_CT_SIGNATURE_HEADER	=0x300+2,
+    OPS_PTAG_CT_SIGNATURE_FOOTER	=0x300+3,
+    OPS_PTAG_CT_ARMOUR_HEADER		=0x300+4,
+    OPS_PTAG_CT_ARMOUR_TRAILER		=0x300+5,
+    OPS_PTAG_CT_SIGNED_CLEARTEXT_HEADER	=0x300+6,
+    OPS_PTAG_CT_SIGNED_CLEARTEXT_BODY	=0x300+7,
+    OPS_PTAG_CT_SIGNED_CLEARTEXT_TRAILER=0x300+8,
+    OPS_PTAG_CT_UNARMOURED_TEXT		=0x300+9,
+    OPS_PTAG_CT_ENCRYPTED_SECRET_KEY	=0x300+10, // In this case the algorithm specific fields will not be initialised
+    OPS_PTAG_CT_SE_DATA_HEADER		=0x300+11,
+    OPS_PTAG_CT_SE_DATA_BODY		=0x300+12,
+    OPS_PTAG_CT_SE_IP_DATA_HEADER	=0x300+13,
+    OPS_PTAG_CT_SE_IP_DATA_BODY		=0x300+14,
+    OPS_PTAG_CT_ENCRYPTED_PK_SESSION_KEY=0x300+15,
+
+    /* commands to the callback */
+    OPS_PARSER_CMD_GET_SK_PASSPHRASE	=0x400,
+    OPS_PARSER_CMD_GET_SECRET_KEY	=0x400+1,
+    OPS_PARSER_CMD_GET_SK_PASSPHRASE_PREV_WAS_BAD =0x400+2,
+
+
+    /* Errors */
+    OPS_PARSER_ERROR			=0x500,	/*!< Internal Use: Parser Error */
+    OPS_PARSER_ERRCODE			=0x500+1, /*! < Internal Use: Parser Error with errcode returned */
+    };
+
+/** Used to specify whether subpackets should be returned raw, parsed or ignored.
+ */
+
+enum ops_parse_type_t
+    {
+    OPS_PARSE_RAW,	/*!< Callback Raw */
+    OPS_PARSE_PARSED,	/*!< Callback Parsed */
+    OPS_PARSE_IGNORE, 	/*!< Don't callback */
+    };
+
+typedef struct _ops_crypt_t ops_crypt_t;
+
+/** ops_hash_t */
+typedef struct _ops_hash_t ops_hash_t;
+
+/** 
+   keep both ops_content_tag_t and ops_packet_tag_t because we might
+   want to introduce some bounds checking i.e. is this really a valid value
+   for a packet tag? 
+*/
+typedef enum ops_content_tag_t ops_packet_tag_t;
+/** SS types are a subset of all content types.
+*/
+typedef enum ops_content_tag_t ops_ss_type_t;
+/* typedef enum ops_sig_type_t ops_sig_type_t; */
+
+/** Revocation Reason type */
+typedef unsigned char ops_ss_rr_code_t;
+
+/** ops_parse_type_t */
+
+/** Used to specify whether subpackets should be returned raw, parsed or ignored.
+ */
+
+typedef enum ops_parse_type_t ops_parse_type_t;
+
+/** ops_parser_content_t */
+typedef struct ops_parser_content_t ops_parser_content_t;
+
+/** Reader Flags */
+/*
+typedef enum
+    {
+    OPS_RETURN_LENGTH=1,
+    } ops_reader_flags_t;
+typedef enum ops_reader_ret_t ops_reader_ret_t;
+*/
+
+/** Writer flags */
+typedef enum
+    {
+    OPS_WF_DUMMY,
+    } ops_writer_flags_t;
+
+/**
+ * \ingroup Create
+ * Contains the required information about how to write
+ */
+typedef struct ops_create_info ops_create_info_t;
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/util.c
+++ b/openpgpsdk/src/openpgpsdk/util.c
--- a/openpgpsdk/src/openpgpsdk/util.h
+++ b/openpgpsdk/src/openpgpsdk/util.h
@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_UTIL_H
+#define OPS_UTIL_H
+
+#include "openpgpsdk/types.h"
+#include "openpgpsdk/create.h"
+#include "openpgpsdk/packet-parse.h"
+#include <stdlib.h>
+
+#define ops_false	0
+#define ops_true	1
+
+void hexdump(const unsigned char *src,size_t length);
+
+/*
+ * These macros code ensures that you are casting what you intend to cast.
+ * It works because in "a ? b : c", b and c must have the same type.
+ * This is a copy of the macro defined in openssl/asn1.h.
+ */
+#ifndef CHECKED_PTR_OF
+#define CHECKED_PTR_OF(type, p) ((void*) (1 ? p : (type *)0))
+#endif 
+#define CHECKED_INSTANCE_OF(type, p) (1 ? p : (type)0) 
+#define DECONST(type,p) ((type *)CHECKED_PTR_OF(const type, p))
+
+/* number of elements in an array */
+#define OPS_ARRAY_SIZE(a)	(sizeof(a)/sizeof(*(a)))
+
+void *ops_mallocz(size_t n);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/validate.c
+++ b/openpgpsdk/src/openpgpsdk/validate.c
--- a/openpgpsdk/src/openpgpsdk/validate.h
+++ b/openpgpsdk/src/openpgpsdk/validate.h
@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+typedef struct
+    {
+    unsigned int valid_count;
+    ops_signature_info_t * valid_sigs;
+    unsigned int invalid_count;
+    ops_signature_info_t * invalid_sigs;
+    unsigned int unknown_signer_count;
+    ops_signature_info_t * unknown_sigs;
+    } ops_validate_result_t;
+
+void ops_validate_result_free(ops_validate_result_t *result);
+
+ops_boolean_t ops_validate_key_signatures(ops_validate_result_t *result,
+                                 const ops_keydata_t* keydata,
+                                 const ops_keyring_t *ring,
+                                 ops_parse_cb_return_t cb (const ops_parser_content_t *, ops_parse_cb_info_t *));
+ops_boolean_t ops_validate_all_signatures(ops_validate_result_t *result,
+                                 const ops_keyring_t *ring,
+                                 ops_parse_cb_return_t (const ops_parser_content_t *, ops_parse_cb_info_t *));
+
+void ops_keydata_reader_set(ops_parse_info_t *pinfo,
+			     const ops_keydata_t *key);
+
+typedef struct
+    {
+    const ops_keydata_t *key;
+    unsigned packet;
+    unsigned offset;
+    } validate_reader_arg_t;
+
+/** Struct used with the validate_key_cb callback */
+typedef struct
+    {
+    ops_public_key_t pkey;
+    ops_public_key_t subkey;
+    ops_secret_key_t skey;
+    enum
+	{
+	ATTRIBUTE=1,
+	ID,
+	} last_seen;
+    ops_user_id_t user_id;
+    ops_user_attribute_t user_attribute;
+    unsigned char hash[OPS_MAX_HASH_SIZE];
+    const ops_keyring_t *keyring;
+    validate_reader_arg_t *rarg;
+    ops_validate_result_t *result;
+    ops_parse_cb_return_t (*cb_get_passphrase) (const ops_parser_content_t *, ops_parse_cb_info_t *);
+    } validate_key_cb_arg_t;
+
+/** Struct use with the validate_data_cb callback */
+typedef struct validate_data_cb_arg
+    {
+    enum
+        {
+        LITERAL_DATA,
+        SIGNED_CLEARTEXT
+        } use; /*<! this is set to indicate what kind of data we have */
+
+
+        ops_literal_data_body_t literal_data_body; /*<! Used to hold Literal Data */
+        ops_signed_cleartext_body_t signed_cleartext_body; /*<! Used to hold Signed Cleartext */
+
+    unsigned char hash[OPS_MAX_HASH_SIZE]; /*<! the hash */
+    const ops_keyring_t *keyring; /*<! keyring to use */
+    validate_reader_arg_t *rarg; /*<! reader-specific arg */
+    ops_validate_result_t *result; /*<! where to put the result */
+    } validate_data_cb_arg_t; /*<! used with validate_data_cb callback */
+
+ops_boolean_t ops_check_signature(const unsigned char *hash,
+                                  unsigned length,
+                                  const ops_signature_t *sig,
+                                  const ops_public_key_t *signer);
+ops_parse_cb_return_t
+ops_validate_key_cb(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);
+
+ops_boolean_t ops_validate_file(ops_validate_result_t* result, const char* filename, const int armoured, const ops_keyring_t* keyring);
+ops_boolean_t ops_validate_mem(ops_validate_result_t *result, ops_memory_t* mem, const int armoured, const ops_keyring_t* keyring);
+ops_boolean_t ops_validate_detached_signature(const void *literal_data, unsigned int literal_data_length, const unsigned char *signature_packet, unsigned int signature_packet_length,const ops_keydata_t *signers_key) ;
+
+
+// EOF
--- a/openpgpsdk/src/openpgpsdk/version.h
+++ b/openpgpsdk/src/openpgpsdk/version.h
@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define OPS_VERSION_MAJOR	0
+/* Set to the version next to be released */
+#define OPS_VERSION_MINOR	9
+/* 0 for development version, 1 for release */
+#define OPS_VERSION_RELEASE	1
+
+#define OPS_VERSION		((OPS_VERSION_MAJOR << 16)+(OPS_VERSION_MINOR << 1)+OPS_VERSION_RELEASE)
+
+#if OPS_VERSION_RELEASE
+# define OPS_DEV_STRING ""
+#else
+# define OPS_DEV_STRING " (dev)"
+#endif
+
+
+#define OPS_VERSION_CAT(a,b)	"OpenPGP:SDK v" #a "." #b OPS_DEV_STRING
+#define OPS_VERSION_CAT2(a,b)	OPS_VERSION_CAT(a,b)
+#define OPS_VERSION_STRING	OPS_VERSION_CAT2(OPS_VERSION_MAJOR,OPS_VERSION_MINOR)
--- a/openpgpsdk/src/openpgpsdk/writer.c
+++ b/openpgpsdk/src/openpgpsdk/writer.c
--- a/openpgpsdk/src/openpgpsdk/writer.h
+++ b/openpgpsdk/src/openpgpsdk/writer.h
@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** \file
+ */
+
+#ifndef OPS_WRITER_H
+#define OPS_WRITER_H
+
+#include "types.h"
+#include "packet.h"
+#include "crypto.h"
+#include "memory.h"
+#include "errors.h"
+#include "keyring.h"
+
+/**
+ * \ingroup Create
+ * This struct contains the required information about one writer
+ */
+/**
+ * \ingroup Writer
+ * the writer function prototype
+ */
+
+typedef struct ops_writer_info ops_writer_info_t;
+typedef ops_boolean_t ops_writer_t(const unsigned char *src,
+				      unsigned length,
+				      ops_error_t **errors,
+				      ops_writer_info_t *winfo);
+typedef ops_boolean_t ops_writer_finaliser_t(ops_error_t **errors,
+					     ops_writer_info_t *winfo);
+typedef void ops_writer_destroyer_t(ops_writer_info_t *winfo);
+/** Writer settings */
+struct ops_writer_info
+    {
+    ops_writer_t *writer; /*!< the writer itself */
+    ops_writer_finaliser_t *finaliser; /*!< the writer's finaliser */
+    ops_writer_destroyer_t *destroyer; /*!< the writer's destroyer */
+    void *arg; /* writer-specific argument */
+    ops_writer_info_t *next; /*!< next writer in the stack */
+    };
+
+
+void *ops_writer_get_arg(ops_writer_info_t *winfo);
+ops_boolean_t ops_stacked_write(const void *src,unsigned length,
+				ops_error_t **errors,
+				ops_writer_info_t *winfo);
+
+void ops_writer_set(ops_create_info_t *info,
+		    ops_writer_t *writer,
+		    ops_writer_finaliser_t *finaliser,
+		    ops_writer_destroyer_t *destroyer,
+		    void *arg);
+void ops_writer_push(ops_create_info_t *info,
+		     ops_writer_t *writer,
+		     ops_writer_finaliser_t *finaliser,
+		     ops_writer_destroyer_t *destroyer,
+		     void *arg);
+void ops_writer_pop(ops_create_info_t *info);
+void ops_writer_generic_destroyer(ops_writer_info_t *winfo);
+ops_boolean_t ops_writer_passthrough(const unsigned char *src,
+				     unsigned length,
+				     ops_error_t **errors,
+				     ops_writer_info_t *winfo);
+
+void ops_writer_set_fd(ops_create_info_t *info,int fd);
+ops_boolean_t ops_writer_close(ops_create_info_t *info);
+
+ops_boolean_t ops_write(const void *src,unsigned length,
+			ops_create_info_t *opt);
+ops_boolean_t ops_write_length(unsigned length,ops_create_info_t *opt);
+ops_boolean_t ops_write_ptag(ops_content_tag_t tag,ops_create_info_t *opt);
+ops_boolean_t ops_write_scalar(unsigned n,unsigned length,
+			       ops_create_info_t *opt);
+ops_boolean_t ops_write_mpi(const BIGNUM *bn,ops_create_info_t *opt);
+ops_boolean_t ops_write_encrypted_mpi(const BIGNUM *bn, ops_crypt_t* crypt, ops_create_info_t *info);
+
+void writer_info_delete(ops_writer_info_t *winfo);
+ops_boolean_t writer_info_finalise(ops_error_t **errors, ops_writer_info_t *winfo);
+
+#endif
--- a/openpgpsdk/src/openpgpsdk/writer_armour.c
+++ b/openpgpsdk/src/openpgpsdk/writer_armour.c
--- a/openpgpsdk/src/openpgpsdk/writer_armoured.h
+++ b/openpgpsdk/src/openpgpsdk/writer_armoured.h
@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
+ * All rights reserved.
+ * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
+ * their moral rights under the UK Copyright Design and Patents Act 1988 to
+ * be recorded as the authors of this copyright work.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. 
+ * 
+ * You may obtain a copy of the License at 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * 
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <openpgpsdk/armour.h>
+
+ops_boolean_t ops_writer_push_clearsigned(ops_create_info_t *info,
+				  ops_create_signature_t *sig);
+void ops_writer_push_armoured_message(ops_create_info_t *info);
+ops_boolean_t ops_writer_switch_to_armoured_signature(ops_create_info_t *info);
+
+void ops_writer_push_armoured(ops_create_info_t *info, ops_armor_type_t type);
+
+// EOF
--- a/openpgpsdk/src/openpgpsdk/writer_encrypt.c
+++ b/openpgpsdk/src/openpgpsdk/writer_encrypt.c
--- a/openpgpsdk/src/openpgpsdk/writer_encrypt_se_ip.c
+++ b/openpgpsdk/src/openpgpsdk/writer_encrypt_se_ip.c
--- a/openpgpsdk/src/openpgpsdk/writer_fd.c
+++ b/openpgpsdk/src/openpgpsdk/writer_fd.c
--- a/openpgpsdk/src/openpgpsdk/writer_literal.c
+++ b/openpgpsdk/src/openpgpsdk/writer_literal.c
--- a/openpgpsdk/src/openpgpsdk/writer_memory.c
+++ b/openpgpsdk/src/openpgpsdk/writer_memory.c
--- a/openpgpsdk/src/openpgpsdk/writer_partial.c
+++ b/openpgpsdk/src/openpgpsdk/writer_partial.c
--- a/openpgpsdk/src/openpgpsdk/writer_skey_checksum.c
+++ b/openpgpsdk/src/openpgpsdk/writer_skey_checksum.c
--- a/openpgpsdk/src/openpgpsdk/writer_stream_encrypt_se_ip.c
+++ b/openpgpsdk/src/openpgpsdk/writer_stream_encrypt_se_ip.c
--- a/openpgpsdk/src/src.pro
+++ b/openpgpsdk/src/src.pro
@ -6,12 +6,16 @@ DEFINES *= OPENSSL_NO_IDEA
 QMAKE_CXXFLAGS *= -Wall -Werror -W 

 TARGET = ops
-DESTDIR = ../lib
+DESTDIR = lib
 DEPENDPATH += .
-INCLUDEPATH += . ../include
+INCLUDEPATH += . 

 #################################### Windows #####################################

+linux-* {
+	OBJECTS_DIR = temp/linux/obj
+}
+
 win32 {
 	SSL_DIR = ../../../../OpenSSL
 	ZLIB_DIR = ../../../zlib-1.2.3
@ -21,41 +25,75 @@ win32 {
 }

 # Input
-HEADERS += keyring_local.h parse_local.h
-SOURCES += accumulate.c \
-           compress.c \
-           create.c \
-           crypto.c \
-           errors.c \
-           fingerprint.c \
-           hash.c \
-           keyring.c \
-           lists.c \
-           memory.c \
-           openssl_crypto.c \
-           packet-parse.c \
-           packet-print.c \
-           packet-show.c \
-           random.c \
-           reader.c \
-           reader_armoured.c \
-           reader_encrypted_se.c \
-           reader_encrypted_seip.c \
-           reader_fd.c \
-           reader_hashed.c \
-           reader_mem.c \
-           readerwriter.c \
-           signature.c \
-           symmetric.c \
-           util.c \
-           validate.c \
-           writer.c \
-           writer_armour.c \
-           writer_partial.c \
-           writer_literal.c \
-           writer_encrypt.c \
-           writer_encrypt_se_ip.c \
-           writer_fd.c \
-           writer_memory.c \
-           writer_skey_checksum.c \
-           writer_stream_encrypt_se_ip.c
+HEADERS += openpgpsdk/writer.h \
+           openpgpsdk/writer_armoured.h \
+           openpgpsdk/version.h \
+           openpgpsdk/validate.h \
+           openpgpsdk/util.h \
+           openpgpsdk/types.h \
+           openpgpsdk/streamwriter.h \
+           openpgpsdk/std_print.h \
+           openpgpsdk/signature.h \
+           openpgpsdk/readerwriter.h \
+           openpgpsdk/random.h \
+           openpgpsdk/partial.h \
+           openpgpsdk/packet-show.h \
+           openpgpsdk/packet-show-cast.h \
+           openpgpsdk/packet-parse.h \
+           openpgpsdk/packet.h \
+           openpgpsdk/memory.h \
+           openpgpsdk/literal.h \
+           openpgpsdk/lists.h \
+           openpgpsdk/keyring.h \
+           openpgpsdk/hash.h \
+           openpgpsdk/final.h \
+           openpgpsdk/defs.h \
+           openpgpsdk/errors.h \
+           openpgpsdk/crypto.h \
+           openpgpsdk/create.h \
+           openpgpsdk/configure.h \
+           openpgpsdk/compress.h \
+           openpgpsdk/callback.h \
+           openpgpsdk/accumulate.h \
+           openpgpsdk/armour.h \
+           openpgpsdk/parse_local.h \
+           openpgpsdk/keyring_local.h
+
+          
+SOURCES += openpgpsdk/accumulate.c \
+           openpgpsdk/compress.c \
+           openpgpsdk/create.c \
+           openpgpsdk/crypto.c \
+           openpgpsdk/errors.c \
+           openpgpsdk/fingerprint.c \
+           openpgpsdk/hash.c \
+           openpgpsdk/keyring.c \
+           openpgpsdk/lists.c \
+           openpgpsdk/memory.c \
+           openpgpsdk/openssl_crypto.c \
+           openpgpsdk/packet-parse.c \
+           openpgpsdk/packet-print.c \
+           openpgpsdk/packet-show.c \
+           openpgpsdk/random.c \
+           openpgpsdk/reader.c \
+           openpgpsdk/reader_armoured.c \
+           openpgpsdk/reader_encrypted_se.c \
+           openpgpsdk/reader_encrypted_seip.c \
+           openpgpsdk/reader_fd.c \
+           openpgpsdk/reader_hashed.c \
+           openpgpsdk/reader_mem.c \
+           openpgpsdk/readerwriter.c \
+           openpgpsdk/signature.c \
+           openpgpsdk/symmetric.c \
+           openpgpsdk/util.c \
+           openpgpsdk/validate.c \
+           openpgpsdk/writer.c \
+           openpgpsdk/writer_armour.c \
+           openpgpsdk/writer_partial.c \
+           openpgpsdk/writer_literal.c \
+           openpgpsdk/writer_encrypt.c \
+           openpgpsdk/writer_encrypt_se_ip.c \
+           openpgpsdk/writer_fd.c \
+           openpgpsdk/writer_memory.c \
+           openpgpsdk/writer_skey_checksum.c \
+           openpgpsdk/writer_stream_encrypt_se_ip.c