github-mirrors/php-gnupg
1
0
Fork 0
mirror of https://github.com/php-gnupg/php-gnupg.git synced 2024-11-21 22:17:09 +00:00
Code Issues Projects Releases Packages Activity

Make initial port to phpc

Browse source
This commit is contained in:
Jakub Zelenka 2016-05-21 21:27:06 +01:00
parent 30fab6eaf9
commit fdf573ac73
5 changed files with 321 additions and 303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.gitignore vendored
View file

@ -63,6 +63,10 @@ tests/*.log
tests/*.out tests/*.out
tests/*.php tests/*.php
tests/*.sh tests/*.sh
tests/pubring.kbx
tests/random_seed
tests/sshcontrol
tests/trustdb.gpg
# coverage # coverage
/coverage.info /coverage.info

3
.gitmodules vendored Normal file
View file

@ -0,0 +1,3 @@
[submodule "phpc"]
path = phpc
url = https://github.com/bukka/phpc

402
gnupg.c
View file

@ -17,34 +17,41 @@
#include "config.h" #include "config.h"
#endif #endif
#include <stddef.h>
#include "php.h" #include "php.h"
#include "php_ini.h" #include "php_ini.h"
#include "zend_exceptions.h" #include "zend_exceptions.h"
#include "ext/standard/info.h" #include "ext/standard/info.h"
#include "php_gnupg.h" #include "php_gnupg.h"
#include "phpc/phpc.h"
#include "php_gnupg_keylistiterator.h" #include "php_gnupg_keylistiterator.h"
static int le_gnupg; static int le_gnupg;
static zend_object_handlers gnupg_object_handlers; PHPC_OBJ_DEFINE_HANDLER_VAR(gnupg);
/* {{{ defs */ /* {{{ GNUPG_GETOBJ */
#define GNUPG_GETOBJ() \ #define GNUPG_GETOBJ() \
zval *this = getThis(); \ zval *this = getThis(); \
gnupg_object *intern; \ PHPC_THIS_DECLARE(gnupg) = NULL; \
zval *res; \ zval *res; \
if(this){ \ do { \
intern = Z_GNUPGO_P(this); \ if (this) { \
if(!intern){ \ PHPC_THIS_FETCH_FROM_ZVAL(gnupg, this); \
if (!PHPC_THIS) { \
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \
RETURN_FALSE; \ RETURN_FALSE; \
} \ } \
} } \
} while(0)
/* }}} */
/* {{{ GNUPG_ERR */
#define GNUPG_ERR(error) \ #define GNUPG_ERR(error) \
if(intern){ \ if (PHPC_THIS) { \
switch (intern->errormode) { \ switch (PHPC_THIS->errormode) { \
case 1: \ case 1: \
php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \ php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \
break; \ break; \
@ -52,115 +59,120 @@ static zend_object_handlers gnupg_object_handlers;
zend_throw_exception(zend_exception_get_default(TSRMLS_C), (char*) error, 0 TSRMLS_CC); \ zend_throw_exception(zend_exception_get_default(TSRMLS_C), (char*) error, 0 TSRMLS_CC); \
break; \ break; \
default: \ default: \
intern->errortxt = (char*)error; \ PHPC_THIS->errortxt = (char*)error; \
} \ } \
}else{ \ } else { \
php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \ php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \
} \ } \
if(return_value){ \ do { \
if (return_value) { \
RETVAL_FALSE; \ RETVAL_FALSE; \
} } \
} while(0)
/* }}} */ /* }}} */
/* {{{ free encryptkeys */ /* {{{ gnupg_free_encryptkeys */
static void gnupg_free_encryptkeys(gnupg_object *intern TSRMLS_DC){ static void gnupg_free_encryptkeys(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC)
if(intern){ {
if (PHPC_THIS) {
int idx; int idx;
/* loop through all encryptkeys and unref them in the gpgme-lib */ /* loop through all encryptkeys and unref them in the gpgme-lib */
for(idx=0;idx<intern->encrypt_size;idx++){ for (idx=0; idx < PHPC_THIS->encrypt_size; idx++){
gpgme_key_unref (intern->encryptkeys[idx]); gpgme_key_unref(PHPC_THIS->encryptkeys[idx]);
} }
/* it´s an odd-thing, but other solutions makes problems : /* it's an odd-thing, but other solutions makes problems :
* erealloc(x,0) gives a segfault with PHP 4 and debug enabled * erealloc(x,0) gives a segfault with PHP 4 and debug enabled
* efree(x) alone ends in a segfault * efree(x) alone ends in a segfault
*/ */
efree(erealloc(intern->encryptkeys,0)); efree(erealloc(PHPC_THIS->encryptkeys, 0));
intern->encryptkeys = NULL; PHPC_THIS->encryptkeys = NULL;
intern->encrypt_size = 0; PHPC_THIS->encrypt_size = 0;
} }
} }
/* }}} */ /* }}} */
/* {{{ free_resource */ /* {{{ gnupg_free_resource_ptre */
static void gnupg_free_resource_ptr(gnupg_object *intern TSRMLS_DC){ static void gnupg_free_resource_ptr(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC)
if(intern){ {
if(intern->ctx){ if (PHPC_THIS) {
if (PHPC_THIS->ctx) {
/* clear all signers from the gpgme-lib and finally release it */ /* clear all signers from the gpgme-lib and finally release it */
gpgme_signers_clear (intern->ctx); gpgme_signers_clear(PHPC_THIS->ctx);
gpgme_release (intern->ctx); gpgme_release(PHPC_THIS->ctx);
intern->ctx = NULL; PHPC_THIS->ctx = NULL;
} }
/* basic cleanup */ /* basic cleanup */
gnupg_free_encryptkeys(intern TSRMLS_CC); gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC);
zend_hash_destroy(intern->signkeys); zend_hash_destroy(PHPC_THIS->signkeys);
FREE_HASHTABLE(intern->signkeys); FREE_HASHTABLE(PHPC_THIS->signkeys);
zend_hash_destroy(intern->decryptkeys); zend_hash_destroy(PHPC_THIS->decryptkeys);
FREE_HASHTABLE(intern->decryptkeys); FREE_HASHTABLE(PHPC_THIS->decryptkeys);
} }
} }
/* }}} */ /* }}} */
/* {{{ gnupg_res_dtor */ /* {{{ gnupg_res_dtor */
ZEND_RSRC_DTOR_FUNC(gnupg_res_dtor) { static void gnupg_res_dtor(phpc_res_entry_t *rsrc TSRMLS_DC) /* {{{ */
gnupg_object *intern = res->ptr; {
gnupg_free_resource_ptr(intern); PHPC_THIS_DECLARE(gnupg) = rsrc->ptr;
efree(intern); gnupg_free_resource_ptr(PHPC_THIS);
efree(PHPC_THIS);
} }
/* }}} */ /* }}} */
/* {{{ gnupg_res_init */ /* {{{ gnupg_res_init */
static void gnupg_res_init(gnupg_object *intern TSRMLS_DC){ static void gnupg_res_init(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC)
{
/* init the gpgme-lib and set the default values */ /* init the gpgme-lib and set the default values */
gpgme_ctx_t ctx; gpgme_ctx_t ctx;
gpgme_error_t err; gpgme_error_t err;
gpgme_check_version (NULL); gpgme_check_version(NULL);
err = gpgme_new(&ctx); err = gpgme_new(&ctx);
if(err == GPG_ERR_NO_ERROR) { if (err == GPG_ERR_NO_ERROR) {
#ifdef GNUPG_PATH #ifdef GNUPG_PATH
gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, GNUPG_PATH, NULL); gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, GNUPG_PATH, NULL);
#endif #endif
gpgme_set_armor (ctx,1); gpgme_set_armor(ctx,1);
} }
intern->ctx = ctx; PHPC_THIS->ctx = ctx;
intern->encryptkeys = NULL; PHPC_THIS->encryptkeys = NULL;
intern->encrypt_size = 0; PHPC_THIS->encrypt_size = 0;
intern->signmode = GPGME_SIG_MODE_CLEAR; PHPC_THIS->signmode = GPGME_SIG_MODE_CLEAR;
intern->errortxt = NULL; PHPC_THIS->errortxt = NULL;
intern->errormode = 3; PHPC_THIS->errormode = 3;
ALLOC_HASHTABLE (intern->signkeys); ALLOC_HASHTABLE(PHPC_THIS->signkeys);
zend_hash_init (intern->signkeys, 0, NULL, NULL, 0); zend_hash_init(PHPC_THIS->signkeys, 0, NULL, NULL, 0);
ALLOC_HASHTABLE (intern->decryptkeys); ALLOC_HASHTABLE(PHPC_THIS->decryptkeys);
zend_hash_init (intern->decryptkeys, 0, NULL, NULL, 0); zend_hash_init(PHPC_THIS->decryptkeys, 0, NULL, NULL, 0);
return;
} }
/* }}} */ /* }}} */
/* {{{ free_storage */ /* {{{ free gnupg */
static void gnupg_obj_dtor(zend_object *intern TSRMLS_DC){ PHPC_OBJ_HANDLER_FREE(gnupg)
gnupg_object *gnupg_o; {
gnupg_o = gnupg_object_from_obj(intern); PHPC_OBJ_HANDLER_FREE_INIT(gnupg);
gnupg_free_resource_ptr(gnupg_o); gnupg_free_resource_ptr(PHPC_THIS TSRMLS_CC);
zend_object_std_dtor(&gnupg_o->zo);
PHPC_OBJ_HANDLER_FREE_DESTROY();
} }
/* }}} */
/* {{{ create_ex gnupg */
PHPC_OBJ_HANDLER_CREATE_EX(gnupg)
{
PHPC_OBJ_HANDLER_CREATE_EX_INIT(gnupg);
/* {{{ objects_new */ gnupg_res_init(PHPC_THIS TSRMLS_CC);
static zend_object* gnupg_obj_new(zend_class_entry *class_type TSRMLS_DC){
gnupg_object *intern;
intern = ecalloc(1, sizeof(gnupg_object) + zend_object_properties_size(class_type)); PHPC_OBJ_HANDLER_CREATE_EX_RETURN(gnupg);
zend_object_std_init(&intern->zo, class_type);
object_properties_init(&intern->zo, class_type);
intern->zo.handlers = &gnupg_object_handlers;
gnupg_res_init (intern TSRMLS_CC);
return &intern->zo;
} }
/* }}} */
/* {{{ create gnupg_object */
PHPC_OBJ_HANDLER_CREATE(gnupg)
{
PHPC_OBJ_HANDLER_CREATE_RETURN(gnupg);
}
/* {{{ arginfo gnupg_verify_method */ /* {{{ arginfo gnupg_verify_method */
ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_method, 0, 0, 2) ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_method, 0, 0, 2)
@ -178,7 +190,7 @@ ZEND_END_ARG_INFO()
/* }}} */ /* }}} */
/* {{{ methodlist gnupg */ /* {{{ methodlist gnupg */
static zend_function_entry gnupg_methods[] = { phpc_function_entry gnupg_methods[] = {
PHP_FALIAS(keyinfo, gnupg_keyinfo, NULL) PHP_FALIAS(keyinfo, gnupg_keyinfo, NULL)
PHP_FALIAS(verify, gnupg_verify, arginfo_gnupg_verify_method) PHP_FALIAS(verify, gnupg_verify, arginfo_gnupg_verify_method)
PHP_FALIAS(geterror, gnupg_geterror, NULL) PHP_FALIAS(geterror, gnupg_geterror, NULL)
@ -202,16 +214,10 @@ static zend_function_entry gnupg_methods[] = {
PHP_FALIAS(gettrustlist, gnupg_gettrustlist, NULL) PHP_FALIAS(gettrustlist, gnupg_gettrustlist, NULL)
PHP_FALIAS(listsignatures, gnupg_listsignatures, NULL) PHP_FALIAS(listsignatures, gnupg_listsignatures, NULL)
PHP_FALIAS(seterrormode, gnupg_seterrormode, NULL) PHP_FALIAS(seterrormode, gnupg_seterrormode, NULL)
{NULL, NULL, NULL} PHPC_FE_END
}; };
/* }}} */ /* }}} */
/* {{{ class constants */
static void gnupg_declare_long_constant(const char *const_name, long value TSRMLS_DC){
zend_declare_class_constant_long(gnupg_class_entry, (char*)const_name, strlen(const_name), value TSRMLS_CC);
}
/* }}} */
/* {{{ arginfo gnupg_verify_method */ /* {{{ arginfo gnupg_verify_method */
ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_function, 0, 0, 3) ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_function, 0, 0, 3)
ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, res)
@ -279,21 +285,31 @@ zend_module_entry gnupg_module_entry = {
ZEND_GET_MODULE(gnupg) ZEND_GET_MODULE(gnupg)
#endif #endif
/* {{{ class constants */
static inline void gnupg_declare_long_constant(const char *const_name, long value TSRMLS_DC)
{
zend_declare_class_constant_long(gnupg_class_entry, (char*)const_name, strlen(const_name), value TSRMLS_CC);
}
/* }}} */
/* {{{ PHP_MINIT_FUNCTION /* {{{ PHP_MINIT_FUNCTION
*/ */
PHP_MINIT_FUNCTION(gnupg) PHP_MINIT_FUNCTION(gnupg)
{ {
le_gnupg = zend_register_list_destructors_ex(gnupg_res_dtor, NULL, "ctx", module_number);
zend_class_entry ce; zend_class_entry ce;
/* init classes */
INIT_CLASS_ENTRY(ce, "gnupg", gnupg_methods); INIT_CLASS_ENTRY(ce, "gnupg", gnupg_methods);
ce.create_object = gnupg_obj_new; PHPC_CLASS_SET_HANDLER_CREATE(ce, gnupg);
gnupg_class_entry = zend_register_internal_class(&ce TSRMLS_CC); gnupg_class_entry = PHPC_CLASS_REGISTER(ce);
PHPC_OBJ_INIT_HANDLERS(gnupg);
PHPC_OBJ_SET_HANDLER_OFFSET(gnupg);
PHPC_OBJ_SET_HANDLER_FREE(gnupg);
memcpy(&gnupg_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); /* register resource */
gnupg_object_handlers.offset = XtOffsetOf(gnupg_object, zo); le_gnupg = zend_register_list_destructors_ex(gnupg_res_dtor, NULL, "ctx", module_number);
gnupg_object_handlers.free_obj = gnupg_obj_dtor;
if (SUCCESS != gnupg_keylistiterator_init()){ if (SUCCESS != gnupg_keylistiterator_init()) {
return FAILURE; return FAILURE;
} }
gnupg_declare_long_constant("SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL TSRMLS_CC); gnupg_declare_long_constant("SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL TSRMLS_CC);
@ -346,6 +362,7 @@ PHP_MINIT_FUNCTION(gnupg)
REGISTER_LONG_CONSTANT("GNUPG_ERROR_WARNING", 1, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_WARNING", 1, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_ERROR_EXCEPTION", 2, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_EXCEPTION", 2, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_ERROR_SILENT", 3, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_SILENT", 3, CONST_CS | CONST_PERSISTENT);
return SUCCESS; return SUCCESS;
} }
/* }}} */ /* }}} */
@ -362,17 +379,20 @@ PHP_MSHUTDOWN_FUNCTION(gnupg)
*/ */
PHP_MINFO_FUNCTION(gnupg) PHP_MINFO_FUNCTION(gnupg)
{ {
const char *php_gpgme_version = gpgme_check_version(NULL);
php_info_print_table_start(); php_info_print_table_start();
php_info_print_table_header(2, "gnupg support", "enabled"); 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_row(2, "GPGme Version", php_gpgme_version);
php_info_print_table_row(2,"Extension Version",PHP_GNUPG_VERSION); php_info_print_table_row(2, "Extension Version", PHP_GNUPG_VERSION);
php_info_print_table_end(); php_info_print_table_end();
} }
/* }}} */ /* }}} */
/* {{{ callback func for setting the passphrase */ /* {{{ 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 TSRMLS_DC){ gpgme_error_t passphrase_cb(PHPC_THIS_DECLARE(gnupg), const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC)
{
char uid[17]; char uid[17];
int idx; int idx;
char *passphrase = NULL; char *passphrase = NULL;
@ -386,7 +406,7 @@ gpgme_error_t passphrase_cb (gnupg_object *intern, const char *uid_hint, const c
uid[idx] = uid_hint[idx]; uid[idx] = uid_hint[idx];
} }
uid[16] = '\0'; uid[16] = '\0';
if((passphrase = zend_hash_str_find_ptr(intern->signkeys,(char *) uid, 16)) == NULL){ if((passphrase = zend_hash_str_find_ptr(PHPC_THIS->signkeys,(char *) uid, 16)) == NULL){
GNUPG_ERR("no passphrase set"); GNUPG_ERR("no passphrase set");
return 1; return 1;
} }
@ -403,7 +423,7 @@ gpgme_error_t passphrase_cb (gnupg_object *intern, const char *uid_hint, const c
return 1; return 1;
} }
gpgme_error_t passphrase_decrypt_cb (gnupg_object *intern, const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC){ gpgme_error_t passphrase_decrypt_cb (PHPC_THIS_DECLARE(gnupg), const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC){
char uid[17]; char uid[17];
int idx; int idx;
char *passphrase = NULL; char *passphrase = NULL;
@ -417,7 +437,7 @@ gpgme_error_t passphrase_decrypt_cb (gnupg_object *intern, const char *uid_hint,
uid[idx] = uid_hint[idx]; uid[idx] = uid_hint[idx];
} }
uid[16] = '\0'; uid[16] = '\0';
if((passphrase = zend_hash_str_find_ptr(intern->decryptkeys,(char *) uid, 16)) == NULL){ if((passphrase = zend_hash_str_find_ptr(PHPC_THIS->decryptkeys,(char *) uid, 16)) == NULL){
GNUPG_ERR("no passphrase set"); GNUPG_ERR("no passphrase set");
return 1; return 1;
} }
@ -459,10 +479,10 @@ int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr){
* inits gnupg and returns a resource * inits gnupg and returns a resource
*/ */
PHP_FUNCTION(gnupg_init){ PHP_FUNCTION(gnupg_init){
gnupg_object *intern; PHPC_THIS_DECLARE(gnupg);
intern = emalloc(sizeof(gnupg_object)); PHPC_THIS = emalloc(sizeof(gnupg_object));
gnupg_res_init(intern TSRMLS_CC); gnupg_res_init(PHPC_THIS TSRMLS_CC);
RETURN_RES(zend_register_resource(intern,le_gnupg)); RETURN_RES(zend_register_resource(PHPC_THIS,le_gnupg));
} }
/* }}} */ /* }}} */
@ -484,14 +504,14 @@ PHP_FUNCTION(gnupg_setarmor){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if(armor > 1){ if(armor > 1){
armor = 1; /*just to make sure */ armor = 1; /*just to make sure */
} }
gpgme_set_armor (intern->ctx,armor); gpgme_set_armor (PHPC_THIS->ctx,armor);
RETURN_TRUE; RETURN_TRUE;
} }
/* }}} */ /* }}} */
@ -510,16 +530,16 @@ PHP_FUNCTION(gnupg_seterrormode){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
switch(errormode){ switch(errormode){
case 1: /* warning */ case 1: /* warning */
case 3: /* silent */ case 3: /* silent */
intern->errormode = errormode; PHPC_THIS->errormode = errormode;
break; break;
case 2: /* exception */ case 2: /* exception */
intern->errormode = errormode; PHPC_THIS->errormode = errormode;
break; break;
default: default:
GNUPG_ERR("invalid errormode"); GNUPG_ERR("invalid errormode");
@ -543,13 +563,13 @@ PHP_FUNCTION(gnupg_setsignmode){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
switch(signmode){ switch(signmode){
case GPGME_SIG_MODE_NORMAL: case GPGME_SIG_MODE_NORMAL:
case GPGME_SIG_MODE_DETACH: case GPGME_SIG_MODE_DETACH:
case GPGME_SIG_MODE_CLEAR: case GPGME_SIG_MODE_CLEAR:
intern->signmode = signmode; PHPC_THIS->signmode = signmode;
RETVAL_TRUE; RETVAL_TRUE;
break; break;
default: default:
@ -570,12 +590,12 @@ PHP_FUNCTION(gnupg_geterror){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if(!intern->errortxt){ if(!PHPC_THIS->errortxt){
RETURN_FALSE; RETURN_FALSE;
}else{ }else{
RETURN_STRINGL(intern->errortxt, strlen(intern->errortxt)); RETURN_STRINGL(PHPC_THIS->errortxt, strlen(PHPC_THIS->errortxt));
} }
} }
/* }}} */ /* }}} */
@ -617,16 +637,16 @@ PHP_FUNCTION(gnupg_keyinfo)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_op_keylist_start(intern->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_keylist_start(PHPC_THIS->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("could not init keylist"); GNUPG_ERR("could not init keylist");
return; return;
} }
array_init(return_value); array_init(return_value);
while(!(intern->err = gpgme_op_keylist_next(intern->ctx, &gpgme_key))){ while(!(PHPC_THIS->err = gpgme_op_keylist_next(PHPC_THIS->ctx, &gpgme_key))){
array_init (&subarr); array_init (&subarr);
array_init (&subkeys); array_init (&subkeys);
@ -711,9 +731,9 @@ PHP_FUNCTION(gnupg_addsignkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
return; return;
} }
@ -721,12 +741,12 @@ PHP_FUNCTION(gnupg_addsignkey){
gpgme_subkey = gpgme_key->subkeys; gpgme_subkey = gpgme_key->subkeys;
while(gpgme_subkey){ while(gpgme_subkey){
if(gpgme_subkey->can_sign == 1){ if(gpgme_subkey->can_sign == 1){
zend_hash_str_add_ptr(intern->signkeys, (char *) gpgme_subkey->keyid, (uint) strlen(gpgme_subkey->keyid), passphrase); zend_hash_str_add_ptr(PHPC_THIS->signkeys, (char *) gpgme_subkey->keyid, (uint) strlen(gpgme_subkey->keyid), passphrase);
} }
gpgme_subkey = gpgme_subkey->next; gpgme_subkey = gpgme_subkey->next;
} }
} }
if((intern->err = gpgme_signers_add(intern->ctx, gpgme_key))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_signers_add(PHPC_THIS->ctx, gpgme_key))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not add signer"); GNUPG_ERR("could not add signer");
}else{ }else{
RETVAL_TRUE; RETVAL_TRUE;
@ -755,16 +775,16 @@ PHP_FUNCTION(gnupg_adddecryptkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
return; return;
} }
gpgme_subkey = gpgme_key->subkeys; gpgme_subkey = gpgme_key->subkeys;
while(gpgme_subkey){ while(gpgme_subkey){
if(gpgme_subkey->secret == 1){ if(gpgme_subkey->secret == 1){
zend_hash_str_add_ptr(intern->decryptkeys, (char *) gpgme_subkey->keyid, strlen(gpgme_subkey->keyid), passphrase); zend_hash_str_add_ptr(PHPC_THIS->decryptkeys, (char *) gpgme_subkey->keyid, strlen(gpgme_subkey->keyid), passphrase);
} }
gpgme_subkey = gpgme_subkey->next; gpgme_subkey = gpgme_subkey->next;
} }
@ -790,17 +810,17 @@ PHP_FUNCTION(gnupg_addencryptkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
return; return;
} }
intern->encryptkeys = erealloc(intern->encryptkeys, sizeof(intern->encryptkeys) * (intern->encrypt_size + 2)); PHPC_THIS->encryptkeys = erealloc(PHPC_THIS->encryptkeys, sizeof(PHPC_THIS->encryptkeys) * (PHPC_THIS->encrypt_size + 2));
intern->encryptkeys[intern->encrypt_size] = gpgme_key; PHPC_THIS->encryptkeys[PHPC_THIS->encrypt_size] = gpgme_key;
intern->encrypt_size++; PHPC_THIS->encrypt_size++;
intern->encryptkeys[intern->encrypt_size] = NULL; PHPC_THIS->encryptkeys[PHPC_THIS->encrypt_size] = NULL;
RETURN_TRUE; RETURN_TRUE;
} }
/* }}} */ /* }}} */
@ -815,11 +835,11 @@ PHP_FUNCTION(gnupg_clearsignkeys){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
gpgme_signers_clear (intern->ctx); gpgme_signers_clear (PHPC_THIS->ctx);
zend_hash_clean(intern->signkeys); zend_hash_clean(PHPC_THIS->signkeys);
RETURN_TRUE; RETURN_TRUE;
} }
/* }}} */ /* }}} */
@ -834,9 +854,9 @@ PHP_FUNCTION(gnupg_clearencryptkeys){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
gnupg_free_encryptkeys(intern TSRMLS_CC); gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC);
RETURN_TRUE; RETURN_TRUE;
} }
@ -852,10 +872,10 @@ PHP_FUNCTION(gnupg_cleardecryptkeys){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
zend_hash_clean(intern->decryptkeys); zend_hash_clean(PHPC_THIS->decryptkeys);
RETURN_TRUE; RETURN_TRUE;
} }
/* }}} */ /* }}} */
@ -885,21 +905,21 @@ PHP_FUNCTION(gnupg_sign){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_cb, PHPC_THIS);
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
return; return;
} }
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer"); GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
if((intern->err = gpgme_op_sign(intern->ctx, in, out, intern->signmode))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_sign(PHPC_THIS->ctx, in, out, PHPC_THIS->signmode))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){ if(!PHPC_THIS->errortxt){
GNUPG_ERR("data signing failed"); GNUPG_ERR("data signing failed");
} }
gpgme_data_release(in); gpgme_data_release(in);
@ -907,7 +927,7 @@ PHP_FUNCTION(gnupg_sign){
RETVAL_FALSE; RETVAL_FALSE;
return; return;
} }
result = gpgme_op_sign_result (intern->ctx); result = gpgme_op_sign_result (PHPC_THIS->ctx);
if(result->invalid_signers){ if(result->invalid_signers){
GNUPG_ERR("invalid signers found"); GNUPG_ERR("invalid signers found");
gpgme_data_release(in); gpgme_data_release(in);
@ -955,28 +975,28 @@ PHP_FUNCTION(gnupg_encrypt){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if(!intern->encryptkeys){ if(!PHPC_THIS->encryptkeys){
GNUPG_ERR("no key for encryption set"); GNUPG_ERR("no key for encryption set");
return; return;
} }
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could no create in-data buffer"); GNUPG_ERR("could no create in-data buffer");
return; return;
} }
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer"); GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
if((intern->err = gpgme_op_encrypt(intern->ctx, intern->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_encrypt(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("encrypt failed"); GNUPG_ERR("encrypt failed");
gpgme_data_release(in); gpgme_data_release(in);
gpgme_data_release(out); gpgme_data_release(out);
return; return;
} }
result = gpgme_op_encrypt_result (intern->ctx); result = gpgme_op_encrypt_result (PHPC_THIS->ctx);
if (result->invalid_recipients){ if (result->invalid_recipients){
GNUPG_ERR("Invalid recipient encountered"); GNUPG_ERR("Invalid recipient encountered");
gpgme_data_release(in); gpgme_data_release(in);
@ -1017,25 +1037,25 @@ PHP_FUNCTION(gnupg_encryptsign){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if(!intern->encryptkeys){ if(!PHPC_THIS->encryptkeys){
GNUPG_ERR("no key for encryption set"); GNUPG_ERR("no key for encryption set");
return; return;
} }
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_cb, PHPC_THIS);
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
return; return;
} }
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer"); GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
if((intern->err = gpgme_op_encrypt_sign(intern->ctx, intern->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_encrypt_sign(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){ if(!PHPC_THIS->errortxt){
GNUPG_ERR("encrypt-sign failed"); GNUPG_ERR("encrypt-sign failed");
} }
gpgme_data_release(in); gpgme_data_release(in);
@ -1044,7 +1064,7 @@ PHP_FUNCTION(gnupg_encryptsign){
return; return;
} }
result = gpgme_op_encrypt_result (intern->ctx); result = gpgme_op_encrypt_result (PHPC_THIS->ctx);
if (result->invalid_recipients){ if (result->invalid_recipients){
GNUPG_ERR("Invalid recipient encountered"); GNUPG_ERR("Invalid recipient encountered");
gpgme_data_release(in); gpgme_data_release(in);
@ -1052,7 +1072,7 @@ PHP_FUNCTION(gnupg_encryptsign){
return; return;
} }
sign_result = gpgme_op_sign_result (intern->ctx); sign_result = gpgme_op_sign_result (PHPC_THIS->ctx);
if(sign_result->invalid_signers){ if(sign_result->invalid_signers){
GNUPG_ERR("invalid signers found"); GNUPG_ERR("invalid signers found");
gpgme_data_release(in); gpgme_data_release(in);
@ -1100,42 +1120,42 @@ PHP_FUNCTION(gnupg_verify){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if(Z_TYPE_P(signature) == IS_STRING){ /* detached signature */ if(Z_TYPE_P(signature) == IS_STRING){ /* detached signature */
/* setup signature-databuffer for gpgme */ /* setup signature-databuffer for gpgme */
if((intern->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signature), Z_STRLEN_P(signature), 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signature), Z_STRLEN_P(signature), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create signature-databuffer"); GNUPG_ERR ("could not create signature-databuffer");
return; return;
} }
/* and the text */ /* and the text */
if((intern->err = gpgme_data_new_from_mem (&gpgme_text, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&gpgme_text, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create text-databuffer"); GNUPG_ERR ("could not create text-databuffer");
gpgme_data_release (gpgme_sig); gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text); gpgme_data_release (gpgme_text);
return; return;
} }
/* now verify sig + text */ /* now verify sig + text */
if((intern->err = gpgme_op_verify (intern->ctx, gpgme_sig, gpgme_text, NULL))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_verify (PHPC_THIS->ctx, gpgme_sig, gpgme_text, NULL))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("verify failed"); GNUPG_ERR ("verify failed");
gpgme_data_release (gpgme_sig); gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text); gpgme_data_release (gpgme_text);
return; return;
} }
}else{ /* clearsign or normal signature */ }else{ /* clearsign or normal signature */
if((intern->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create signature-databuffer"); GNUPG_ERR ("could not create signature-databuffer");
return; return;
} }
/* set a NULL databuffer for gpgme */ /* set a NULL databuffer for gpgme */
if((intern->err = gpgme_data_new_from_mem (&gpgme_text, NULL, 0, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&gpgme_text, NULL, 0, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create text-databuffer"); GNUPG_ERR ("could not create text-databuffer");
gpgme_data_release (gpgme_sig); gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text); gpgme_data_release (gpgme_text);
return; return;
} }
/* and verify the 'signature' */ /* and verify the 'signature' */
if((intern->err = gpgme_op_verify (intern->ctx, gpgme_sig, NULL, gpgme_text))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_verify (PHPC_THIS->ctx, gpgme_sig, NULL, gpgme_text))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("verify failed"); GNUPG_ERR ("verify failed");
gpgme_data_release (gpgme_sig); gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text); gpgme_data_release (gpgme_text);
@ -1143,7 +1163,7 @@ PHP_FUNCTION(gnupg_verify){
} }
} }
/* now get the result */ /* now get the result */
gpgme_result = gpgme_op_verify_result (intern->ctx); gpgme_result = gpgme_op_verify_result (PHPC_THIS->ctx);
if(!gpgme_result->signatures){ if(!gpgme_result->signatures){
GNUPG_ERR ("no signature found"); GNUPG_ERR ("no signature found");
}else{ }else{
@ -1184,21 +1204,21 @@ PHP_FUNCTION(gnupg_decrypt){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_decrypt_cb, intern); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_decrypt_cb, PHPC_THIS);
if((intern->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
} }
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer"); GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
if((intern->err = gpgme_op_decrypt (intern->ctx, in, out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_decrypt (PHPC_THIS->ctx, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){ if(!PHPC_THIS->errortxt){
GNUPG_ERR("decrypt failed"); GNUPG_ERR("decrypt failed");
} }
gpgme_data_release(in); gpgme_data_release(in);
@ -1206,7 +1226,7 @@ PHP_FUNCTION(gnupg_decrypt){
RETVAL_FALSE; RETVAL_FALSE;
return; return;
} }
result = gpgme_op_decrypt_result (intern->ctx); result = gpgme_op_decrypt_result (PHPC_THIS->ctx);
if (result->unsupported_algorithm){ if (result->unsupported_algorithm){
GNUPG_ERR("unsupported algorithm"); GNUPG_ERR("unsupported algorithm");
gpgme_data_release(in); gpgme_data_release(in);
@ -1248,22 +1268,22 @@ PHP_FUNCTION(gnupg_decryptverify){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
ZVAL_DEREF(plaintext); ZVAL_DEREF(plaintext);
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_decrypt_cb, intern); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_decrypt_cb, PHPC_THIS);
if((intern->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
} }
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer"); GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
if((intern->err = gpgme_op_decrypt_verify (intern->ctx, in, out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_decrypt_verify (PHPC_THIS->ctx, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){ if(!PHPC_THIS->errortxt){
GNUPG_ERR("decrypt-verify failed"); GNUPG_ERR("decrypt-verify failed");
} }
gpgme_data_release(in); gpgme_data_release(in);
@ -1274,13 +1294,13 @@ PHP_FUNCTION(gnupg_decryptverify){
userret = gpgme_data_release_and_get_mem(out,&ret_size); userret = gpgme_data_release_and_get_mem(out,&ret_size);
ZVAL_STRINGL (plaintext,userret,ret_size); ZVAL_STRINGL (plaintext,userret,ret_size);
free (userret); free (userret);
decrypt_result = gpgme_op_decrypt_result (intern->ctx); decrypt_result = gpgme_op_decrypt_result (PHPC_THIS->ctx);
if (decrypt_result->unsupported_algorithm){ if (decrypt_result->unsupported_algorithm){
GNUPG_ERR ("unsupported algorithm"); GNUPG_ERR ("unsupported algorithm");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
verify_result = gpgme_op_verify_result (intern->ctx); verify_result = gpgme_op_verify_result (PHPC_THIS->ctx);
if(!verify_result->signatures){ if(!verify_result->signatures){
GNUPG_ERR ("no signature found"); GNUPG_ERR ("no signature found");
gpgme_data_release(in); gpgme_data_release(in);
@ -1312,13 +1332,13 @@ PHP_FUNCTION(gnupg_export){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create data buffer"); GNUPG_ERR("could not create data buffer");
return; return;
} }
if((intern->err = gpgme_op_export (intern->ctx, searchkey, 0, out))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_export (PHPC_THIS->ctx, searchkey, 0, out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("export failed"); GNUPG_ERR("export failed");
gpgme_data_release(out); gpgme_data_release(out);
return; return;
@ -1352,19 +1372,19 @@ PHP_FUNCTION(gnupg_import){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_data_new_from_mem (&in, importkey, importkey_len, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_data_new_from_mem (&in, importkey, importkey_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
return; return;
} }
if((intern->err = gpgme_op_import(intern->ctx,in)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_import(PHPC_THIS->ctx,in)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("import failed"); GNUPG_ERR("import failed");
gpgme_data_release(in); gpgme_data_release(in);
return; return;
} }
gpgme_data_release(in); gpgme_data_release(in);
result = gpgme_op_import_result (intern->ctx); result = gpgme_op_import_result (PHPC_THIS->ctx);
if(!result || !result->imports || result->imports->result != GPG_ERR_NO_ERROR){ if(!result || !result->imports || result->imports->result != GPG_ERR_NO_ERROR){
RETURN_FALSE; RETURN_FALSE;
@ -1404,14 +1424,14 @@ PHP_FUNCTION(gnupg_deletekey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_get_key(intern->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
return; return;
} }
if((intern->err = gpgme_op_delete(intern->ctx,gpgme_key,allow_secret))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_delete(PHPC_THIS->ctx,gpgme_key,allow_secret))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("delete failed"); GNUPG_ERR("delete failed");
RETVAL_FALSE; RETVAL_FALSE;
}else{ }else{
@ -1441,14 +1461,14 @@ PHP_FUNCTION(gnupg_gettrustlist){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_op_trustlist_start (intern->ctx, pattern, 0))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_op_trustlist_start (PHPC_THIS->ctx, pattern, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not start trustlist"); GNUPG_ERR("could not start trustlist");
return; return;
} }
array_init(return_value); array_init(return_value);
while (!(intern->err = gpgme_op_trustlist_next (intern->ctx, &item))){ while (!(PHPC_THIS->err = gpgme_op_trustlist_next (PHPC_THIS->ctx, &item))){
array_init (&sub_arr); array_init (&sub_arr);
add_assoc_long (&sub_arr, "level", item->level ); add_assoc_long (&sub_arr, "level", item->level );
@ -1485,13 +1505,13 @@ PHP_FUNCTION(gnupg_listsignatures){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE){ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE){
return; return;
} }
intern = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg);
} }
if((intern->err = gpgme_set_keylist_mode(intern->ctx,GPGME_KEYLIST_MODE_SIGS))!=GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_set_keylist_mode(PHPC_THIS->ctx,GPGME_KEYLIST_MODE_SIGS))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not switch to sigmode"); GNUPG_ERR("could not switch to sigmode");
return; return;
} }
if((intern->err = gpgme_get_key(intern->ctx, keyid, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){ if((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, keyid, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed. given key not unique?"); GNUPG_ERR("get_key failed. given key not unique?");
return; return;
} }

16
php_gnupg.h
View file

@ -32,8 +32,9 @@ extern zend_module_entry gnupg_module_entry;
#endif #endif
#include <gpgme.h> #include <gpgme.h>
#include "phpc/phpc.h"
typedef struct gnupg_object{ PHPC_OBJ_STRUCT_BEGIN(gnupg)
gpgme_ctx_t ctx; gpgme_ctx_t ctx;
gpgme_error_t err; gpgme_error_t err;
int errormode; int errormode;
@ -43,21 +44,10 @@ typedef struct gnupg_object{
unsigned int encrypt_size; unsigned int encrypt_size;
HashTable *signkeys; HashTable *signkeys;
HashTable *decryptkeys; HashTable *decryptkeys;
zend_object zo; PHPC_OBJ_STRUCT_END()
} gnupg_object;
static zend_class_entry *gnupg_class_entry; static zend_class_entry *gnupg_class_entry;
static inline gnupg_object *gnupg_object_from_obj(zend_object *obj) /* {{{ */ {
return (gnupg_object*)((char*)(obj) - XtOffsetOf(gnupg_object, zo));
}
/* }}} */
static inline gnupg_object *Z_GNUPGO_P(zval *zv) /* {{{ */ {
return gnupg_object_from_obj(Z_OBJ_P((zv)));
}
/* }}} */
PHP_MINIT_FUNCTION(gnupg); PHP_MINIT_FUNCTION(gnupg);
PHP_MSHUTDOWN_FUNCTION(gnupg); PHP_MSHUTDOWN_FUNCTION(gnupg);
PHP_MINFO_FUNCTION(gnupg); PHP_MINFO_FUNCTION(gnupg);

1
phpc Submodule

@ -0,0 +1 @@
Subproject commit 28b8bdf2a78a31772a325099806eb984ac9063ea