initial release

LICENSE

@@ -0,0 +1,68 @@
+-------------------------------------------------------------------- 
+                  The PHP License, version 3.0
+Copyright (c) 1999 - 2002 The PHP Group. All rights reserved.
+-------------------------------------------------------------------- 
+
+Redistribution and use in source and binary forms, with or without
+modification, is permitted provided that the following conditions
+are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+ 
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+ 
+  3. The name "PHP" must not be used to endorse or promote products
+     derived from this software without prior written permission. For
+     written permission, please contact group@php.net.
+  
+  4. Products derived from this software may not be called "PHP", nor
+     may "PHP" appear in their name, without prior written permission
+     from group@php.net.  You may indicate that your software works in
+     conjunction with PHP by saying "Foo for PHP" instead of calling
+     it "PHP Foo" or "phpfoo"
+ 
+  5. The PHP Group may publish revised and/or new versions of the
+     license from time to time. Each version will be given a
+     distinguishing version number.
+     Once covered code has been published under a particular version
+     of the license, you may always continue to use it under the terms
+     of that version. You may also choose to use such covered code
+     under the terms of any subsequent version of the license
+     published by the PHP Group. No one other than the PHP Group has
+     the right to modify the terms applicable to covered code created
+     under this License.
+
+  6. Redistributions of any form whatsoever must retain the following
+     acknowledgment:
+     "This product includes PHP, freely available from
+     <http://www.php.net/>".
+
+THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND 
+ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE PHP
+DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------- 
+
+This software consists of voluntary contributions made by many
+individuals on behalf of the PHP Group.
+
+The PHP Group can be contacted via Email at group@php.net.
+
+For more information on the PHP Group and the PHP project, 
+please see <http://www.php.net>.
+
+This product includes the Zend Engine, freely available at
+<http://www.zend.com>.

README

@@ -0,0 +1,131 @@
+Installation
+------------
+tar xvzf gnupg-x.y.tgz
+cd gnupg_x-y
+phpize
+make
+make install
+
+This extension requires the gpgme library, which is available at http://www.gnupg.org/(en)/download/index.html#gpgme
+
+
+Notes
+-----
+
+-	This extension requires PHP 5.
+	It was tested with 5.0.5
+
+-	This is a beta version.
+	Don´t use it on production systems.
+	See this release more like a "preview" or something like that.
+
+-	This extension makes currently no write-operations on your keyring.
+	But a backup of them is always a good idea
+
+-	Only the Open_PGP protocol is currently supported.
+	This shouldn´t be a problem for the most people.
+
+-	extending this class is currently not tested.
+
+-	only 1 key per operation is currently supported.
+	so you can´t add x keys for encryption.
+
+-	Whenever you provide a key to a method, you should make sure, that your given pattern is unique.
+	Otherwise it could happen, that the wrong key is selected from the keyring.
+	The best would be to provide the fingerprint, whenever needed.
+
+-	The underlying lib checks for the presence of the gpg-agent.
+	If a passphrase is required for an operation, this agent is asked first.
+	To avoid this, clear the enviroment-variable GPG_AGENT_INFO (see http://de3.php.net/manual/en/function.putenv.php)
+
+-	This extension is class based
+	No "global" constants are defined. Only class constants
+
+		SIG_MODE_NORMAL
+		SIG_MODE_DETACH
+		SIG_MODE_CLEAR
+
+		VALIDITY_UNKNOWN
+		VALIDITY_UNDEFINED
+		VALIDITY_NEVER
+		VALIDITY_MARGINAL
+		VALIDITY_FULL
+		VALIDITY_ULTIMATE
+
+		PROTOCOL_OpenPGP
+		PROTOCOL_CMS
+    
+		SIGSUM_VALID
+		SIGSUM_GREEN
+		SIGSUM_RED
+		SIGSUM_KEY_REVOKED
+		SIGSUM_KEY_EXPIRED
+		SIGSUM_SIG_EXPIRED
+		SIGSUM_KEY_MISSING
+		SIGSUM_CRL_MISSING
+		SIGSUM_CRL_TOO_OLD
+		SIGSUM_BAD_POLICY
+		SIGSUM_SYS_ERROR
+
+
+Methods
+-------
+
+-		__construct()
+		sets up a new gnupg object
+		( new gnupg() )
+
+-		bool setarmor(int armor)
+		turn on/off armor mode
+		0 = off
+		>0 = on	(default)
+
+-		bool setsignmode(int signmode)
+		sets the mode for signing operations
+		see the SIG_MODE_* constants
+		default is SIG_MODE_CLEAR
+
+-		bool setpassphrase(string passphrase)
+		sets the passphrase for all next operations
+
+-		string geterror(void)
+		returns the last errormessage
+
+-		int getprotocol(void)
+		returns the currently used pgp-protocol.
+		atm only PROTOCOL_OpenPGP is supported
+
+-		array keyinfo(string pattern)
+		returns an array with informations about all keys, that matches the given pattern
+
+-		bool setsignerkey(string key)
+		sets the private key for the next sign operation.
+		please note, that the given key must return only 1 result from the keyring
+		it should be the best to provide a fingerprint here
+
+-		bool setencryptkey(string key)
+		sets the public key for next encrypt operation.
+		please note, that the given key must return only 1 result from the keyring
+		it should be the best to provide a fingerprint here
+
+-		bool clearsignerkey(void)
+		removes all keys which are set for signing
+
+-		bool clearencryptkey(void)
+		removes all keys which are set for encryption
+
+-		string sign(string text)
+		signs the given test with the key, which was set with setsignerkey before
+		and returns the signed text
+		the signmode depends on gnupg_setsignmode
+
+-		string encrypt(string text)
+		encrypts the given text with the key, which was set with setencryptkey before
+		and returns the encrypted text
+
+-		array verify(string text [, string &plaintext])
+		verifies the given clearsigned text and returns information about the result in an array
+		if plaintext is passed, it is filled with the plaintext (the text without signature)
+
+-		string decrypt(string enctext)
+		decrypts the given enctext

config.m4

@@ -0,0 +1,62 @@
+dnl $Id$
+dnl config.m4 for extension gnupg
+
+dnl Comments in this file start with the string 'dnl'.
+dnl Remove where necessary. This file will not work
+dnl without editing.
+
+dnl If your extension references something external, use with:
+
+PHP_ARG_WITH(gnupg, for gnupg support,
+dnl Make sure that the comment is aligned:
+[  --with-gnupg             Include gnupg support])
+
+dnl Otherwise use enable:
+
+dnl PHP_ARG_ENABLE(gnupg, whether to enable gnupg support,
+dnl Make sure that the comment is aligned:
+dnl [  --enable-gnupg           Enable gnupg support])
+
+if test "$PHP_GNUPG" != "no"; then
+  dnl Write more examples of tests here...
+
+  dnl # --with-gnupg -> check with-path
+  SEARCH_PATH="/usr/local /usr"     # you might want to change this
+  SEARCH_FOR="/include/gpgme.h"  # you most likely want to change this
+  if test -r $PHP_GNUPG/$SEARCH_FOR; then # path given as parameter
+    GNUPG_DIR=$PHP_GNUPG
+  else # search default path list
+    AC_MSG_CHECKING([for gnupg files in default path])
+    for i in $SEARCH_PATH ; do
+      if test -r $i/$SEARCH_FOR; then
+        GNUPG_DIR=$i
+        AC_MSG_RESULT(found in $i)
+      fi
+    done
+  fi
+  
+  if test -z "$GNUPG_DIR"; then
+    AC_MSG_RESULT([not found])
+    AC_MSG_ERROR([Please reinstall the gnupg distribution])
+  fi
+
+  dnl # --with-gnupg -> add include path
+  PHP_ADD_INCLUDE($GNUPG_DIR/include)
+
+  dnl # --with-gnupg -> check for lib and symbol presence
+  LIBNAME=gpgme # you may want to change this
+  LIBSYMBOL=gpgme_check_version # you most likely want to change this 
+
+  PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
+  [
+    PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $GNUPG_DIR/lib, GNUPG_SHARED_LIBADD)
+    AC_DEFINE(HAVE_GNUPGLIB,1,[ ])
+  ],[
+    AC_MSG_ERROR([wrong gnupg lib version or lib not found])
+  ],[
+    -L$GNUPG_DIR/lib -lm -ldl
+  ])
+  PHP_SUBST(GNUPG_SHARED_LIBADD)
+
+  PHP_NEW_EXTENSION(gnupg, gnupg.c, $ext_shared)
+fi

examples/clearsign.php

@@ -0,0 +1,8 @@
+<?php
+require_once	(dirname(__FILE__)."/main.php");
+
+$gnupg		->	setSignerKey		($fingerprint);
+$gnupg		->	setPassPhrase		($passphrase);
+$text		=	$gnupg	->	sign	($mailtext);
+echo $text;
+?>

examples/decrypt.php

@@ -0,0 +1,30 @@
+<?php
+require_once	(dirname(__FILE__)."/main.php");
+
+$mailtext	=	'
+-----BEGIN PGP MESSAGE-----
+Version: GnuPG v1.2.5 (GNU/Linux)
+
+hQIOA8VdBLDv7dV1EAgAtEMlQ1K/iXYIgPLiojfEhaTOvyEhDjZZ/9Gr5IQ/UvXZ
+nQW0KYuIpYB8Oe7SC/n3NDqcLuS9Q8GMBgcQjLQKIjEtu0I2xcXATjpNEooKgSqp
+KxWtoobsPNkCrVyK1dEH911vr/sGcjpiX5L0dYMldq5So45979AaUirpX4pmu7ay
+1YB81iciq3/KmR+ocOMWzT+v6WJFB0rXSoFc1WiwSiw6TcotXdZA9hAllwaRuBMQ
+2Vct7/F+dTqZRD4mBt8WiksJFvPm8bb+5p4QVt9eVkuxJv8w7mROVEDFYsDeh8GG
+FxEzYBr1yv+9DG3Hkmtqk6Ns6VZH4roB9RdwKU2XlggAq/6DiqYnuV9+xuKYvF1G
++8X/MWOg2Di6xqe8GqujGmq3ztFb5wNDc+Rp4aW9YgbHHLf9VFc21QAEozjfTe6S
+hQbcY02UrkJ8bQ4LigWtNnvM3XzQw/J+LQFYij/QogvO3inNVMFd+/WEoJNZ7EMB
+sE68F32hPsumPhpheyfD19SX2Nejrlaqa4qYCuhNUR0luI4Xti6ymX3jAXJsozNa
+zP/Ho1T/fCwohyJYaOe7S+u99fcVrchmGP77qiPNQUMsY1LthY1LMihq+0Kd+ORM
+Hc7HHGvV8/ufIB9WFWNOhQW+gOfIfGzQidLaw+AI7ar68FciKwce9aX99yffVx3U
+y9JHAWS6GctPfUHl1ZiS/1hq5s7xcWHsh7KTPwv449OsXIWFitnDH6jCL1sqQPjq
+3pNJXapRMRsyKi60i8jV+KIDl0O0Q9S6eEY=
+=Rb4q
+-----END PGP MESSAGE-----
+
+';
+
+$gnupg		->	setPassPhrase		($passphrase);
+$plaintext	=	$gnupg	->	decrypt	($mailtext);
+
+echo "\n".$plaintext."\n";
+?>

examples/encrypt.php

@@ -0,0 +1,7 @@
+<?php
+require_once	(dirname(__FILE__)."/main.php");
+
+$gnupg		->	setEncryptKey		($fingerprint);
+$text		=	$gnupg	->	encrypt	($mailtext);
+echo $text;
+?>

examples/keyinfo.php

@@ -0,0 +1,6 @@
+<?php
+require_once    (dirname(__FILE__)."/main.php");
+
+$keyinfo	=	$gnupg		->	keyinfo	($fingerprint);
+print_r($keyinfo)
+?>

examples/main.php

@@ -0,0 +1,9 @@
+<?php
+dl("gnupg.so");
+
+$fingerprint    =       "8660281B6051D071D94B5B230549F9DC851566DC";
+$mailtext       =       "Test test Test TeSt";
+$passphrase     =       "incorrect";
+
+$gnupg			=		new gnupg	();
+?>

examples/verify.php

@@ -0,0 +1,24 @@
+<?php
+require_once	(dirname(__FILE__)."/main.php");
+
+$mailtext	=	'
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA1
+
+Test test Test TeSt
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.2.5 (GNU/Linux)
+
+iD8DBQFDRWw6BUn53IUVZtwRAoVKAJ9P0E0PKcpEuWeHNxgZRbctpETbGQCgv0Nq
+TmrOEDxc5AihrFREY+IYPp4=
+=933C
+-----END PGP SIGNATURE-----
+';
+
+$plaintext	=	false;
+
+$info		=	$gnupg	->	verify	($mailtext,$plaintext);
+
+print_r($info);
+echo "\n".$plaintext."\n";
+?>

gnupg.c

@@ -0,0 +1,820 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2004 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.0 of the PHP license,       |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_0.txt.                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Thilo Raufeisen                                                             |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "php_gnupg.h"
+
+static int le_gnupg;
+
+static zend_object_handlers gnupg_object_handlers;
+
+/* {{{ macros */
+#define GNUPG_FROM_OBJECT(intern, object){			\
+	ze_gnupg_object *obj	=	(ze_gnupg_object*) zend_object_store_get_object(object TSRMLS_CC); \
+	intern = obj->gnupg_ptr; \
+	if(!intern){ \
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \
+		RETURN_FALSE; \
+	} \
+}
+
+#define GNUPG_ERROR(intern, this){ \
+	zend_update_property_string(Z_OBJCE_P(this), this, "error", 5, (char*)gpg_strerror(intern->err) TSRMLS_DC); \
+	RETURN_FALSE; \
+}
+/* }}} */
+
+/* {{{ free_resource */
+static void gnupg_free_resource_ptr(gnupg_object *intern TSRMLS_DC){
+	if(intern){
+		
+		if(intern->ctx){
+			gpgme_signers_clear (intern->ctx);
+			gpgme_release(intern->ctx);
+			intern->ctx = NULL;
+		}
+		zval_dtor(&intern->passphrase);
+		efree(intern);
+	}
+}
+/* }}} */
+
+/* {{{ free_storage */
+static void gnupg_object_free_storage(void *object TSRMLS_DC){
+	ze_gnupg_object * intern = (ze_gnupg_object *) object;
+	if(!intern){
+		return;
+	}
+	if(intern->gnupg_ptr){
+		gnupg_free_resource_ptr(intern->gnupg_ptr TSRMLS_CC);
+	}
+	intern->gnupg_ptr = NULL;
+	if(intern->zo.properties){
+		zend_hash_destroy(intern->zo.properties);
+		FREE_HASHTABLE(intern->zo.properties);
+	}
+	efree(intern);
+}
+/* }}} */
+
+/* {{{ objects_new */
+zend_object_value gnupg_objects_new(zend_class_entry *class_type TSRMLS_DC){
+	ze_gnupg_object *intern;
+	zval *tmp;
+	zend_object_value retval;
+	intern	=	emalloc(sizeof(ze_gnupg_object));
+	intern->zo.ce = class_type;
+	intern->zo.in_get = 0;
+	intern->zo.in_set = 0;
+	intern->zo.properties = NULL;
+	
+	ALLOC_HASHTABLE(intern->zo.properties);
+	zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+	zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+	
+	retval.handle	=	zend_objects_store_put(intern,NULL,(zend_objects_free_object_storage_t) gnupg_object_free_storage,NULL TSRMLS_CC);
+	retval.handlers	=	(zend_object_handlers *) & gnupg_object_handlers;
+	
+	/* hmmm. better in userspace
+	unsetenv ("GPG_AGENT_INFO");
+	*/
+	return retval;
+}
+/* }}} */
+
+/* {{{ resource_destructor */
+void gnupg_resource_destructor(zend_rsrc_list_entry *rsrc TSRMLS_DC){
+	/*
+	if(rsrc->ptr){
+		printf("debug");
+	}
+	*/
+}
+/* }}} */
+
+/* {{{ functionlist */
+function_entry gnupg_functions[] = {
+	{NULL, NULL, NULL}	/* Must be the last line in gnupg_functions[] */
+};
+/* }}} */
+
+/* {{{ methodlist */
+static zend_function_entry gnupg_methods[] = {
+	PHP_ME_MAPPING(__construct,		gnupg_construct,		NULL)
+	PHP_ME_MAPPING(keyinfo,			gnupg_keyinfo,			NULL)
+	PHP_ME_MAPPING(verify,			gnupg_verify,			NULL)
+	PHP_ME_MAPPING(getError,		gnupg_geterror,			NULL)
+	PHP_ME_MAPPING(setpassphrase,	gnupg_setpassphrase,	NULL)
+	PHP_ME_MAPPING(setsignerkey,	gnupg_setsignerkey,		NULL)
+	PHP_ME_MAPPING(clearsignerkey,	gnupg_clearsignerkey,	NULL)
+	PHP_ME_MAPPING(setencryptkey,	gnupg_setencryptkey,	NULL)
+	PHP_ME_MAPPING(setarmor,		gnupg_setarmor,			NULL)
+	PHP_ME_MAPPING(encrypt,			gnupg_encrypt,			NULL)
+	PHP_ME_MAPPING(decrypt,			gnupg_decrypt,			NULL)
+	PHP_ME_MAPPING(export,			gnupg_export,			NULL)
+	PHP_ME_MAPPING(getprotocol,		gnupg_getprotocol,		NULL)
+	PHP_ME_MAPPING(setsignmode,		gnupg_setsignmode,		NULL)
+	PHP_ME_MAPPING(sign,			gnupg_sign,				NULL)
+	{NULL, NULL, NULL}
+};
+/* }}} */
+
+/* {{{ class constants */
+static void gnupg_declare_long_constant(const char *const_name, long value TSRMLS_DC){
+#if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 1
+    zend_declare_class_constant_long(gnupg_class_entry, (char*)const_name, strlen(const_name), value TSRMLS_CC);
+#else
+    zval *constant = malloc(sizeof(*constant));
+    ZVAL_LONG(constant,value);
+    INIT_PZVAL(constant);
+    zend_hash_update(&gnupg_class_entry->constants_table, (char*)const_name, strlen(const_name)+1, &constant, sizeof(zval*), NULL);
+#endif
+
+}
+/* }}} */
+
+/* {{{ properties */
+void register_gnupgProperties(TSRMLS_D){
+	zend_declare_property_long		(gnupg_class_entry, "protocol", 8, GPGME_PROTOCOL_OpenPGP, ZEND_ACC_PROTECTED TSRMLS_DC);
+	zend_declare_property_string	(gnupg_class_entry, "error", 5, "", ZEND_ACC_PROTECTED TSRMLS_DC);
+}
+/* }}} */
+
+/* {{{ gnupg_module_entry
+ */
+zend_module_entry gnupg_module_entry = {
+#if ZEND_MODULE_API_NO >= 20010901
+	STANDARD_MODULE_HEADER,
+#endif
+	"gnupg",
+	gnupg_functions,
+	PHP_MINIT(gnupg),
+	PHP_MSHUTDOWN(gnupg),
+	NULL,		/* Replace with NULL if there's nothing to do at request start */
+	NULL,	/* Replace with NULL if there's nothing to do at request end */
+	PHP_MINFO(gnupg),
+#if ZEND_MODULE_API_NO >= 20010901
+	"0.1", /* Replace with version number for your extension */
+#endif
+	STANDARD_MODULE_PROPERTIES
+};
+/* }}} */
+
+#ifdef COMPILE_DL_GNUPG
+ZEND_GET_MODULE(gnupg)
+#endif
+
+
+
+/* {{{ PHP_MINIT_FUNCTION
+ */
+PHP_MINIT_FUNCTION(gnupg)
+{
+	zend_class_entry ce; 
+	
+	INIT_CLASS_ENTRY(ce, "gnupg", gnupg_methods);
+	
+	ce.create_object	=	gnupg_objects_new;
+	gnupg_class_entry   =   zend_register_internal_class(&ce TSRMLS_CC);
+	memcpy(&gnupg_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	le_gnupg			=	zend_register_list_destructors_ex(gnupg_resource_destructor, NULL, "ctx", module_number);
+	
+	register_gnupgProperties(TSRMLS_CC);
+	gnupg_declare_long_constant("SIG_MODE_NORMAL",            GPGME_SIG_MODE_NORMAL TSRMLS_DC);
+	gnupg_declare_long_constant("SIG_MODE_DETACH",            GPGME_SIG_MODE_DETACH TSRMLS_DC);
+	gnupg_declare_long_constant("SIG_MODE_CLEAR",             GPGME_SIG_MODE_CLEAR TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_UNKNOWN",           GPGME_VALIDITY_UNKNOWN TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_UNDEFINED",         GPGME_VALIDITY_UNDEFINED TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_NEVER",             GPGME_VALIDITY_NEVER TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_MARGINAL",          GPGME_VALIDITY_MARGINAL TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_FULL",              GPGME_VALIDITY_FULL TSRMLS_DC);
+	gnupg_declare_long_constant("VALIDITY_ULTIMATE",          GPGME_VALIDITY_ULTIMATE TSRMLS_DC);
+	gnupg_declare_long_constant("PROTOCOL_OpenPGP",           GPGME_PROTOCOL_OpenPGP TSRMLS_DC);
+	gnupg_declare_long_constant("PROTOCOL_CMS",               GPGME_PROTOCOL_CMS TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_VALID",               GPGME_SIGSUM_VALID TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_GREEN",               GPGME_SIGSUM_GREEN TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_RED",         		  GPGME_SIGSUM_RED TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_KEY_REVOKED",         GPGME_SIGSUM_KEY_REVOKED TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_KEY_EXPIRED",         GPGME_SIGSUM_KEY_EXPIRED TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_SIG_EXPIRED",         GPGME_SIGSUM_SIG_EXPIRED TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_KEY_MISSING",         GPGME_SIGSUM_KEY_MISSING TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_CRL_MISSING",         GPGME_SIGSUM_CRL_MISSING TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_CRL_TOO_OLD",         GPGME_SIGSUM_CRL_TOO_OLD TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_BAD_POLICY",          GPGME_SIGSUM_BAD_POLICY TSRMLS_DC);
+	gnupg_declare_long_constant("SIGSUM_SYS_ERROR",           GPGME_SIGSUM_SYS_ERROR TSRMLS_DC);
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MSHUTDOWN_FUNCTION
+ */
+PHP_MSHUTDOWN_FUNCTION(gnupg)
+{
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION
+ */
+PHP_MINFO_FUNCTION(gnupg)
+{
+	php_info_print_table_start();
+	php_info_print_table_header(2, "gnupg support", "enabled");
+	php_info_print_table_row(2,"GPGme Version",gpgme_check_version(NULL));
+	php_info_print_table_end();
+}
+/* }}} */
+
+/* {{{ callback func for setting the passphrase
+ */
+gpgme_error_t passphrase_cb (gnupg_object *intern, const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd){
+	if(last_was_bad){
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Incorrent passphrase");
+		return 1;
+	}
+	if(Z_STRLEN(intern->passphrase) < 1){
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "no passphrase set");
+		return 1;
+	}
+	write (fd, Z_STRVAL(intern->passphrase), Z_STRLEN(intern->passphrase));
+	write (fd, "\n", 1);
+	return 0;
+	
+}
+/* }}} */
+
+/* {{{proto object gnupg_construct([PROTOCOL])
+ * constructor.
+ * if passed, only GPGME_PROTOCOL_OpenPGP is currently valid
+ */
+PHP_FUNCTION(gnupg_construct){
+	gnupg_object *intern;
+	zval *this = getThis();
+	ze_gnupg_object *ze_obj;
+	
+	int protocol = GPGME_PROTOCOL_OpenPGP;
+	gpgme_ctx_t ctx;
+	gpgme_error_t err;
+		
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &protocol) == FAILURE){
+		return;
+	}
+	if(protocol != GPGME_PROTOCOL_OpenPGP){
+		zend_throw_exception(zend_exception_get_default(),"only OpenPGP is currently supported",1 TSRMLS_CC);
+	}
+	if((err = gpgme_new(&ctx))!=GPG_ERR_NO_ERROR){
+		zend_throw_exception(zend_exception_get_default(),gpg_strerror(err),1 TSRMLS_CC);
+	}
+	gpgme_set_armor	(ctx,1);
+	
+	ze_obj	=	(ze_gnupg_object*) zend_object_store_get_object(this TSRMLS_CC); 
+	intern	=	emalloc(sizeof(gnupg_object));
+	intern->ctx			= ctx;
+	intern->encryptkey	= NULL;
+	intern->signmode	= GPGME_SIG_MODE_CLEAR;
+	ze_obj->gnupg_ptr	= intern;
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_setarmor(int armor)
+ * turn on/off armor mode
+ * 0 = off
+ * >0 = on
+ * */
+PHP_FUNCTION(gnupg_setarmor){
+	int	   		 armor;
+	zval	     *this = getThis();
+	gnupg_object *intern;
+
+	GNUPG_FROM_OBJECT(intern, this);
+	
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &armor) == FAILURE){
+		return;
+	}
+
+	if(armor > 1){
+		armor = 1; /*just to make sure */
+	}
+
+	gpgme_set_armor (intern->ctx,armor);
+	RETURN_TRUE;
+}
+/* }}} */
+
+
+/* {{{ proto bool gnupg_setsignmode(int signmode)
+ * sets the mode for signing operations
+ */
+PHP_FUNCTION(gnupg_setsignmode){
+	int			 signmode;
+	zval		 *this = getThis();
+	gnupg_object *intern;
+
+	GNUPG_FROM_OBJECT(intern, this);
+
+	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"l", &signmode) == FAILURE){
+		return;
+	}
+	switch(signmode){
+		case GPGME_SIG_MODE_NORMAL:
+		case GPGME_SIG_MODE_DETACH:
+		case GPGME_SIG_MODE_CLEAR:
+			intern->signmode = signmode;
+			RETURN_TRUE;
+			break;
+		default:
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid signmode: %i",signmode);
+			RETURN_FALSE; /* not really needed */
+			break;
+	}
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_setpassphrase(string passphrase)
+ * sets the passphrase for all next operations
+ */
+PHP_FUNCTION(gnupg_setpassphrase){
+	zval *tmp;
+	zval *this = getThis();
+	gnupg_object *intern;
+	
+	GNUPG_FROM_OBJECT(intern, this);
+
+	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"z", &tmp) == FAILURE){
+		return;
+	}
+	intern->passphrase = *tmp;
+	zval_copy_ctor(&intern->passphrase);
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string gnupg_geterror(void)
+ * returns the last errormessage
+ */
+PHP_FUNCTION(gnupg_geterror){
+	zval *error;
+	zval *this = getThis();
+	
+	error	= zend_read_property(Z_OBJCE_P(this), this, "error", 5, 1 TSRMLS_CC);
+	RETURN_STRINGL(Z_STRVAL_P(error), Z_STRLEN_P(error), 1);
+}
+/* }}} */
+
+/* {{{ proto int gnupg_getprotocol(void)
+ * returns the currently used pgp-protocol.
+ * atm only OpenPGP is supported
+ */
+PHP_FUNCTION(gnupg_getprotocol){
+	zval *this = getThis();
+	zval *protocol;
+	gnupg_object *intern;
+	GNUPG_FROM_OBJECT(intern, this);
+	protocol	=	zend_read_property(Z_OBJCE_P(this), this, "protocol", 8, 1 TSRMLS_CC);
+	RETURN_LONG(Z_LVAL_P(protocol));
+}
+
+/* }}} */
+
+/* {{{ proto array gnupg_keyinfo(string pattern)
+ * returns an array with informations about all keys, that matches the given pattern
+ */
+PHP_FUNCTION(gnupg_keyinfo)
+{
+	char		*searchkey = NULL;
+	int			*searchkey_len;
+	int			idx;
+	zval		*this = getThis();
+	zval		*subarr;
+	zval		*userid;
+	zval		*userids;
+	zval		*subkey;
+	zval		*subkeys;
+	gnupg_object *intern;
+	
+	gpgme_key_t		gpgkey;
+	gpgme_subkey_t	gpgsubkey;
+	gpgme_user_id_t gpguserid;
+	
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &searchkey, &searchkey_len) == FAILURE){
+		return;
+	}
+	
+	GNUPG_FROM_OBJECT(intern, this);
+	
+	if((intern->err = gpgme_op_keylist_start(intern->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	
+	array_init(return_value);
+	
+	while(!(intern->err = gpgme_op_keylist_next(intern->ctx, &gpgkey))){
+		ALLOC_INIT_ZVAL		(subarr);
+		array_init			(subarr);
+		
+		ALLOC_INIT_ZVAL		(subkeys);
+		array_init			(subkeys);
+		
+		ALLOC_INIT_ZVAL		(userids);
+		array_init			(userids);
+
+		add_assoc_bool      (subarr,	"disabled",		gpgkey->disabled	);
+		add_assoc_bool      (subarr,	"expired",		gpgkey->expired		);
+		add_assoc_bool      (subarr,	"revoked",		gpgkey->revoked		);
+		add_assoc_bool      (subarr,	"is_secret",	gpgkey->secret		);
+		add_assoc_bool      (subarr,	"can_sign",		gpgkey->can_sign	);
+		add_assoc_bool      (subarr,	"can_encrypt",	gpgkey->can_encrypt	);
+		
+		for(idx = 1, gpguserid = gpgkey->uids; gpguserid; idx++, gpguserid = gpguserid->next){
+			ALLOC_INIT_ZVAL		(userid);
+			array_init			(userid);
+			
+			add_assoc_string    (userid,	"name",		gpguserid->name,	1);
+			add_assoc_string	(userid,	"comment",	gpguserid->comment,	1);
+			add_assoc_string    (userid,	"email",	gpguserid->email,	1);
+			add_assoc_string    (userid,	"uid",		gpguserid->uid,		1);
+			
+			add_assoc_bool      (userid,	"revoked",	gpguserid->revoked	);
+			add_assoc_bool      (userid,	"invalid",	gpguserid->invalid	);
+			
+			add_next_index_zval	(userids, userid);
+		}
+		
+		add_assoc_zval			(subarr,	"uids",	userids);
+
+		for(idx = 1, gpgsubkey = gpgkey->subkeys; gpgsubkey; idx++, gpgsubkey = gpgsubkey->next){
+			ALLOC_INIT_ZVAL		(subkey);
+			array_init			(subkey);
+			
+			if(gpgsubkey->fpr){
+				add_assoc_string    (subkey,	"fingerprint",	gpgsubkey->fpr,		1);
+			}
+			
+			add_assoc_string    (subkey,	"keyid",		gpgsubkey->keyid,		1);
+			
+			add_assoc_long	    (subkey,	"timestamp",	gpgsubkey->timestamp	);
+			add_assoc_long	    (subkey,	"expires",		gpgsubkey->expires		);
+			add_assoc_bool	    (subkey,	"is_secret",	gpgsubkey->secret		);
+			add_assoc_bool	    (subkey,	"invalid",		gpgsubkey->invalid		);
+			add_assoc_bool	    (subkey,	"can_encrypt",	gpgsubkey->can_encrypt	);
+			add_assoc_bool	    (subkey,	"can_sign",		gpgsubkey->can_sign		);
+			add_assoc_bool	    (subkey,	"disabled",		gpgsubkey->disabled		);
+			add_assoc_bool	    (subkey,	"expired",		gpgsubkey->expired		);
+			add_assoc_bool	    (subkey,	"revoked",		gpgsubkey->revoked		);
+
+			add_next_index_zval	(subkeys, subkey);
+		}
+		
+		add_assoc_zval		(subarr,	"subkeys",	subkeys);
+
+		add_next_index_zval	(return_value, subarr);
+	}
+	return;
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_setsignerkey(string key)
+ * sets the private key for the next sign operation.
+ * please note, that the given key must return only 1 result from the keyring
+ * it should be the best to provide a fingerprint here
+ */
+PHP_FUNCTION(gnupg_setsignerkey){
+    char	*key_id = NULL;
+    int		key_id_len;
+	
+	zval			*this = getThis();
+	gnupg_object	*intern;
+
+    gpgme_sign_result_t	result;
+	gpgme_key_t			gpgme_key;
+	
+	GNUPG_FROM_OBJECT(intern, this);
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key_id, &key_id_len) == FAILURE){
+        return;
+    }
+	if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+    }
+
+	gpgme_signers_clear	(intern->ctx);
+
+	if((intern->err = gpgme_signers_add(intern->ctx, gpgme_key))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	RETURN_TRUE;	
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_setencryptkey(string key)
+ * sets the public key for next encrypt operation.
+ * please note, that the given key must return only 1 result from the keyring
+ * it should be the best to provide a fingerprint here
+ */
+PHP_FUNCTION(gnupg_setencryptkey){
+	char	*key_id = NULL;
+    int		key_id_len;
+
+	zval			*this = getThis();
+	gnupg_object	*intern;
+
+    gpgme_sign_result_t	result;
+    gpgme_key_t			gpgme_key;
+	
+	GNUPG_FROM_OBJECT(intern, this);
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key_id, &key_id_len) == FAILURE){
+        return;
+	}
+	if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+    }
+	if(intern->encryptkey){
+		gpgme_key_release(intern->encryptkey);
+	}
+	intern->encryptkey = gpgme_key;
+    RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_clearsignerkey(void)
+ * removes all keys which are set for signing
+ */
+PHP_FUNCTION(gnupg_clearsignerkey){
+	zval			*this = getThis();
+	gnupg_object	*intern;
+	
+	GNUPG_FROM_OBJECT	(intern, this);
+	
+	gpgme_signers_clear	(intern->ctx);
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool gnupg_clearencryptkey(void)
+ * removes all keys which are set for encryption
+ */
+PHP_FUNCTION(gnupg_clearencryptkey){
+	zval			*this = getThis();
+	gnupg_object	*intern;
+
+	GNUPG_FROM_OBJECT	(intern, this);
+	
+	gpgme_key_release   (intern->encryptkey);
+
+    RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string gnupg_sign(string text)
+ * signs the given test with the key, which was set with setsignerkey before
+ * and returns the signed text
+ * the signmode depends on gnupg_setsignmode
+ */
+PHP_FUNCTION(gnupg_sign){
+    char    *value = NULL;
+    int     value_len;
+
+    zval    	 *this = getThis();
+    gnupg_object *intern;
+
+    char    *userret;
+    int     ret_size;
+
+    gpgme_data_t in, out;
+
+    GNUPG_FROM_OBJECT(intern, this);
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE){
+        return;
+    }
+    gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern);
+    if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
+        GNUPG_ERROR(intern,this);
+    }
+    if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
+        GNUPG_ERROR(intern,this);
+    }
+    if((intern->err = gpgme_op_sign(intern->ctx, in, out, intern->signmode))!=GPG_ERR_NO_ERROR){
+        GNUPG_ERROR(intern,this);
+    }
+    userret     =   gpgme_data_release_and_get_mem(out,&ret_size);
+    if(ret_size < 1){
+        RETURN_FALSE;
+    }
+    gpgme_data_release  (in);
+    free                (out);
+    RETURN_STRINGL      (userret,ret_size,1);
+}
+
+/* }}} */
+
+/* {{{ proto string gnupg_encrypt(string text)
+ * encrypts the given text with the key, which was set with setencryptkey before
+ * and returns the encrypted text
+ */
+PHP_FUNCTION(gnupg_encrypt){
+	char *value = NULL;
+	int value_len;
+	char *userret = NULL;
+	int ret_size;
+	zval *this = getThis();
+	gnupg_object *intern;
+
+	gpgme_data_t in, out;
+	
+	GNUPG_FROM_OBJECT(intern, this);
+	
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE){
+		return;
+	}
+	
+	if(!intern->encryptkey){
+		zend_update_property_string(Z_OBJCE_P(this), this, "error", 5, "no key for encryption set" TSRMLS_DC);
+		RETURN_FALSE;
+	}
+	if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_op_encrypt(intern->ctx, &intern->encryptkey, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	userret		=	gpgme_data_release_and_get_mem(out,&ret_size);
+	if(ret_size < 1){
+		RETURN_FALSE;
+	}
+	gpgme_data_release  (in);
+	free (out);
+	/*
+	gpgme_key_release   (gpgme_key);
+	*/
+	RETURN_STRINGL      (userret,ret_size,1);
+}
+/* }}} */
+
+/* {{{ proto array gnupg_verify(string text [, string &plaintext])
+ * verifies the given clearsigned text and returns information about the result in an array
+ */
+PHP_FUNCTION(gnupg_verify){
+	char			*value = NULL;
+	char			*sigtext = NULL;
+	int 			value_len;
+	int 			tmp;
+	zval			*plaintext;
+	zval 			*this = getThis();
+	gnupg_object	*intern;
+	
+	char	*userret;
+	int		ret_size;
+
+	gpgme_data_t			in, out;
+	gpgme_verify_result_t	result;
+	gpgme_signature_t		nextsig;
+	
+	GNUPG_FROM_OBJECT(intern, this);
+	
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &value, &value_len, &plaintext) == FAILURE){
+		return;
+	}
+	if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_data_new_from_mem (&out, sigtext, 0, 0))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_op_verify (intern->ctx, in, NULL, out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	result				=	gpgme_op_verify_result (intern->ctx);
+	
+	array_init				(return_value);
+
+	add_assoc_string		(return_value,	"fingerprint",	result->signatures->fpr,		1);
+	add_assoc_long			(return_value,	"validity",		result->signatures->validity	);
+	add_assoc_long			(return_value,	"timestamp",	result->signatures->timestamp	);
+	add_assoc_long			(return_value,	"status",		result->signatures->status		);
+
+	nextsig				=	result->signatures->next;
+	if(nextsig){
+		zend_update_property_string(Z_OBJCE_P(this), this, "error", 5, "multiple signatures found" TSRMLS_DC);
+		RETURN_FALSE;
+	}
+
+    userret         	=   gpgme_data_release_and_get_mem(out,&ret_size);
+	if(plaintext){
+		ZVAL_STRINGL		(plaintext,userret,ret_size,1);
+	}
+	gpgme_data_release  	(in);
+	free					(out);
+}
+/* }}} */
+
+/* {{{ proto string gnupg_decrypt(string enctext)
+ * decrypts the given enctext
+ */
+PHP_FUNCTION(gnupg_decrypt){
+	char			*enctxt;
+	int				enctxt_len;
+
+	zval 			*this = getThis();
+	gnupg_object	*intern;
+
+	char    *userret;
+    int     ret_size;
+	
+	gpgme_data_t			in, out;
+	gpgme_decrypt_result_t	result;
+	  
+	GNUPG_FROM_OBJECT(intern, this);
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &enctxt, &enctxt_len) == FAILURE){
+		return;
+	}
+
+	gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern);
+	
+	if((intern->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_op_decrypt (intern->ctx, in, out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	result = gpgme_op_decrypt_result (intern->ctx);
+
+	userret             =   gpgme_data_release_and_get_mem(out,&ret_size);
+	RETURN_STRINGL			(userret,ret_size,1);
+	gpgme_data_release		(in);
+	free					(out);
+}
+/* }}} */
+
+/* {{{ proto string gnupg_export(string pattern)
+ * exports the first public key which matches against the given pattern
+ */
+PHP_FUNCTION(gnupg_export){
+	char	*searchkey = NULL;
+    int     *searchkey_len;
+	char	*userret;
+    int		ret_size;
+
+	zval 		 *this = getThis();
+	gnupg_object *intern;
+
+	gpgme_data_t  out;
+
+	GNUPG_FROM_OBJECT(intern, this);
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &searchkey, &searchkey_len) == FAILURE){
+		return;
+	}
+	if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	if((intern->err = gpgme_op_export (intern->ctx, searchkey, 0, out))!=GPG_ERR_NO_ERROR){
+		GNUPG_ERROR(intern,this);
+	}
+	userret             =   gpgme_data_release_and_get_mem(out,&ret_size);
+	if(ret_size < 1){
+		RETURN_FALSE;
+	}
+	RETURN_STRINGL          (userret,ret_size,1);
+	free					(out);
+}
+/* }}} */
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */

package.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE package SYSTEM "http://pear.php.net/dtd/package-1.0">
+<package version="1.0" packagerversion="1.4.1">
+ <name>gnupg</name>
+ <summary>wrapper around the gpgme library</summary>
+ <description>This extension provides methods to interact with gnupg.
+So you can sign, encrypt, verify directly from php
+ </description>
+ <maintainers>
+  <maintainer>
+   <user>traufeisen</user>
+   <name>Thilo Raufeisen</name>
+   <email>traufeisen@php.net</email>
+   <role>lead</role>
+  </maintainer>
+  </maintainers>
+ <release>
+  <version>0.1</version>
+  <date>2005-10-07</date>
+  <license>PHP License</license>
+  <state>beta</state>
+  <notes>First release and not feature complete. Don&apos;t use in production enviroments
+  </notes>
+  <deps>
+   <dep type="php" rel="ge" version="5.0"/>
+  </deps>
+  <filelist>
+   <file role="doc" name="LICENSE"/>
+   <file role="doc" name="EXPERIMENTAL"/>
+   <file role="doc" name="README"/>
+   <file role="src" name="config.m4"/>
+   <file role="src" name="php_gnupg.h"/>
+   <file role="src" name="gnupg.c"/>
+   <file role="doc" name="examples/main.php"/>
+   <file role="doc" name="examples/clearsign.php"/>
+   <file role="doc" name="examples/verify.php"/>
+   <file role="doc" name="examples/encrypt.php"/>
+   <file role="doc" name="examples/decrypt.php"/>
+   <file role="doc" name="examples/keyinfo.php"/>
+  </filelist>
+ </release>
+ <changelog>
+   <release>
+    <version>0.1</version>
+    <date>2005-10-07</date>
+    <state>beta</state>
+    <notes>initial release
+    </notes>
+   </release>
+ </changelog>
+</package>

package2.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<package packagerversion="1.4.1" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
+ <name>gnupg</name>
+ <channel>pecl.php.net</channel>
+ <summary>wrapper around the gpgme library</summary>
+ <description>This extension provides methods to interact with gnupg.
+So you can sign, encrypt, verify directly from php</description>
+ <lead>
+  <name>Thilo Raufeisen</name>
+  <user>traufeisen</user>
+  <email>traufeisen@php.net</email>
+  <active>yes</active>
+ </lead>
+ <date>2005-10-07</date>
+ <time>20:17:04</time>
+ <version>
+  <release>0.1</release>
+  <api>0.1</api>
+ </version>
+ <stability>
+  <release>beta</release>
+  <api>beta</api>
+ </stability>
+ <license uri="http://www.php.net/license">PHP License</license>
+ <notes>First release and not feature complete. Don&apos;t use in production enviroments</notes>
+ <contents>
+  <dir name="/">
+   <file md5sum="1f2eefcaf44c8a7533b2ad19c69ede0e" name="examples/clearsign.php" role="doc" />
+   <file md5sum="9ccddfd2c22ccec0fe8b13fd41ccb252" name="examples/decrypt.php" role="doc" />
+   <file md5sum="15c3488ad344ed264ef123d31d49012f" name="examples/encrypt.php" role="doc" />
+   <file md5sum="ba7c637ebaeb12e61d13f2678171cee1" name="examples/keyinfo.php" role="doc" />
+   <file md5sum="7a06adc6cf3139a79a5dfb840d876af1" name="examples/main.php" role="doc" />
+   <file md5sum="d7e45084bed6b4c8c1526056b4e78140" name="examples/verify.php" role="doc" />
+   <file md5sum="180bd17c5bd37dd69bcfe568e7722c02" name="config.m4" role="src" />
+   <file md5sum="d41d8cd98f00b204e9800998ecf8427e" name="EXPERIMENTAL" role="doc" />
+   <file md5sum="39ae229a064d5fe1fa27320ca708d0ec" name="gnupg.c" role="src" />
+   <file md5sum="b4fae3bcb2e182f6758f29542342d332" name="LICENSE" role="doc" />
+   <file md5sum="4d27dece931fbfc08519ca0631845125" name="php_gnupg.h" role="src" />
+   <file md5sum="9f78dcbdab946661590d9ff510bfb0ee" name="README" role="doc" />
+  </dir>
+ </contents>
+ <dependencies>
+  <required>
+   <php>
+    <min>5.0</min>
+   </php>
+   <pearinstaller>
+    <min>1.4.0b1</min>
+   </pearinstaller>
+  </required>
+ </dependencies>
+ <providesextension>gnupg</providesextension>
+ <extsrcrelease />
+ <changelog>
+  <release>
+   <version>
+    <release>0.1</release>
+    <api>0.1</api>
+   </version>
+   <stability>
+    <release>beta</release>
+    <api>beta</api>
+   </stability>
+   <date>2005-10-07</date>
+   <license uri="http://www.php.net/license">PHP License</license>
+   <notes>initial release</notes>
+  </release>
+ </changelog>
+</package>

php_gnupg.h

@@ -0,0 +1,96 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2004 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.0 of the PHP license,       |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_0.txt.                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Thilo Raufeisen                                              |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_GNUPG_H
+#define PHP_GNUPG_H
+
+extern zend_module_entry gnupg_module_entry;
+#define phpext_gnupg_ptr &gnupg_module_entry
+
+#ifdef PHP_WIN32
+#define PHP_GNUPG_API __declspec(dllexport)
+#else
+#define PHP_GNUPG_API
+#endif
+
+#ifdef ZTS
+#include "TSRM.h"
+#endif
+
+#include <gpgme.h>
+
+typedef struct _gnupg_object{
+	gpgme_ctx_t ctx;
+	zval passphrase;
+	gpgme_key_t encryptkey;
+	gpgme_error_t err;
+	int signmode;
+} gnupg_object;
+
+typedef struct _ze_gnupg_object{
+	zend_object zo;
+	gnupg_object *gnupg_ptr;
+} ze_gnupg_object;
+
+
+
+zend_class_entry *gnupg_class_entry;
+
+PHP_MINIT_FUNCTION(gnupg);
+PHP_MSHUTDOWN_FUNCTION(gnupg);
+/*
+PHP_RINIT_FUNCTION(gnupg);
+PHP_RSHUTDOWN_FUNCTION(gnupg);
+*/
+PHP_MINFO_FUNCTION(gnupg);
+
+PHP_FUNCTION(gnupg_construct);
+PHP_FUNCTION(gnupg_keyinfo);
+PHP_FUNCTION(gnupg_verify);
+PHP_FUNCTION(gnupg_geterror);
+PHP_FUNCTION(gnupg_setpassphrase);
+PHP_FUNCTION(gnupg_setsignerkey);
+PHP_FUNCTION(gnupg_setencryptkey);
+PHP_FUNCTION(gnupg_setsignmode);
+PHP_FUNCTION(gnupg_setarmor);
+PHP_FUNCTION(gnupg_sign);
+PHP_FUNCTION(gnupg_clearsignerkey);
+PHP_FUNCTION(gnupg_getprotocol);
+PHP_FUNCTION(gnupg_encrypt);
+PHP_FUNCTION(gnupg_decrypt);
+PHP_FUNCTION(gnupg_export);
+
+#ifdef ZTS
+#define GNUPG_G(v) TSRMG(gnupg_globals_id, zend_gnupg_globals *, v)
+#else
+#define GNUPG_G(v) (gnupg_globals.v)
+#endif
+
+#endif	/* PHP_GNUPG_H */
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */