package.xml0000664000175000017500000003521414163677356012176 0ustar jakubjakub gnupg pecl.php.net wrapper around the gpgme library This extension provides methods to interact with gnupg Jakub Zelenka bukka bukka@php.net yes Jim Jagielski jimjag jimjag@php.net no Sean DuBois seander sean@siobud.com no 2021-12-31 1.5.1 1.5.1 stable stable BSD, revised * Fixed compilation with PHP 8.1 * Fixed build with gpgme 1.4 5.3.2 1.4.0b1 gnupg 2021-04-10 1.5.0 1.5.0 stable stable BSD, revised * Added new README.md 2021-03-07 1.5.0RC2 1.5.0RC2 beta beta BSD, revised * Fixed build with libgpgme 1.3 * Fixed largefile support on 32-bit platforms * Fixed tests in PECL archive 1.5.0RC1 1.5.0RC1 beta beta 2021-02-14 BSD, revised * Added support for PHP 8 * Added support for GnuPG 2.1+ * Added argument info for all functions and methods (reflection support) * Added new function `gnupg_getengineinfo` * Added new function `gnupg_geterrorinfo` * Added init array argument for setting home dir and gpg binary file name * Added additional fields to `gnupg_keyinfo` returned array * Added parameter to `gnupg_keyinfo` to use `secret_only` * Fixed `gnupg_deletekey` to use boolean for `allow_secret` parameter 1.4.0 1.4.0 stable stable 2016-08-29 BSD, revised * No changes since 1.4.0RC2 1.4.0RC2 1.4.0RC2 beta beta 2016-07-24 BSD, revised * Fixed ZTS issue with invalid context for a password callback 1.4.0RC1 1.4.0RC1 beta beta 2016-06-15 BSD, revised * Added support for PHP 7 * Fixed various compilation issues 1.3.6 1.3.6 stable stable 2015-02-11 BSD, revised * Fixed compilation bug 1.3.5 1.3.5 stable stable 2015-02-11 BSD, revised * Fix compatibility with PHP 5.4, 5.5 and 5.6 * Fix iterator bug #65342 1.3.4 1.3.4 beta beta 2013-12-31 BSD, revised * No fixes 1.3.3 1.3.3 stable stable 2013-07-17 BSD, revised * Fix compatibility with PHP 5.4 and 5.5 1.3.2 1.3.2 stable stable 2010-07-20 BSD, revised * Fix compatibility with gpgme >= 1.2.0 and crashes on 64-bit systems 1.3.1 1.3.1 stable stable 2007-05-04 BSD, revised * Fixed double-free with recent gpgme-lib 1.3 1.3 stable stable 2006-11-06 BSD, revised * PHP 5.2 compatibility * gnupg_deletekey now allows deleting a secret key in procedural usage * Bumped min version to 4.4 1.2 1.2 stable stable 2006-05-23 BSD, revised * Fixed bug #7587 (gnupg_verify fails with detached signature) * Added &quot;summary&quot; into signature-array 1.1 1.1 stable stable 2006-03-16 BSD, revised * Improved PHP4 compatibility * Fixed passphrase-errors now takes care of the errormode 1.0 1.0 stable stable 2005-12-29 BSD, revised * Bumped to stable 0.7.1 0.7.1 beta beta 2005-12-01 BSD, revised * Fixed PHP 5.1 build 0.7 0.7 beta beta 2005-11-29 BSD, revised * Changed licence to BSD, revised * Fixed error during keyimport when the keyring is not writeable * Fixed error when an invalid errormode is passed to seterrormode 0.6.1 0.6.1 beta beta 2005-11-12 BSD, revised * Fixed zts build 0.6 0.6 beta beta 2005-11-12 BSD, revised * Added seterrormode * Various memory optimizations 0.5 0.5 beta beta 2005-10-25 BSD, revised * Added support for multiple keys * Added getsignatures * Verify can now handle all signature types 0.4 0.4 beta beta 2005-10-17 BSD, revised * Added procedual usage and lowered min PHP Version to 4.3 0.3 0.3 beta beta 2005-10-15 BSD, revised * Added import/export methods and better errormessages 0.2 0.2 beta beta 2005-10-10 BSD, revised * Added keylistiterator, encryptsign and decryptverify 0.1 0.1 beta beta 2005-10-07 BSD, revised * Initial release gnupg-1.5.1/phpc/phpc.h0000664000175000017500000017101114163677356013672 0ustar jakubjakub/* * Copyright (c) 2014-2016 Jakub Zelenka. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * */ #ifndef PHPC_H #define PHPC_H #if PHP_VERSION_ID < 50199 #error "Only PHP 5.2+ supported" #endif /* no operation */ #define PHPC_NOOP ((void) 0) /* COMMON (used definitions) */ /* common object macros */ #define PHPC_CLASS_TYPE _phpc_class_type #define PHPC_SELF _phpc_self #define PHPC_OBJ_STRUCT_NAME(_name) struct _phpc_##_name##__obj #define PHPC_OBJ_STRUCT_DECLARE(_name, _ptr) PHPC_OBJ_STRUCT_NAME(_name) *_ptr #define PHPC_OBJ_GET_HANDLER_FCE(_name, _type) _name##__##_type #define PHPC_OBJ_DEFINE_HANDLER_FCE(_rtype, _name, _type) \ static _rtype PHPC_OBJ_GET_HANDLER_FCE(_name, _type) #define PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(_rtype, _name, _type) \ PHPC_OBJ_DEFINE_HANDLER_FCE(inline _rtype, _name, _type) #define PHPC_OBJ_GET_HANDLER_VAR_NAME(_name) _phpc_##_name##__handlers #define PHPC_OBJ_DEFINE_HANDLER_VAR(_name) \ static zend_object_handlers PHPC_OBJ_GET_HANDLER_VAR_NAME(_name) #define PHPC_OBJ_INIT_HANDLERS(_name) \ memcpy(&PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), \ zend_get_std_object_handlers(), sizeof(zend_object_handlers)) /* for arginfo */ #ifndef ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX #define ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \ ZEND_BEGIN_ARG_INFO_EX(name, 0, return_reference, required_num_args) #endif /* ZEND_ACC_CTOR and ZEND_ACC_DTOR is removed in 7.4 */ #ifndef ZEND_ACC_CTOR #define ZEND_ACC_CTOR 0 #endif #ifndef ZEND_ACC_DTOR #define ZEND_ACC_DTOR 0 #endif #if PHP_VERSION_ID < 50299 #define phpc_function_entry zend_function_entry #else #define phpc_function_entry const zend_function_entry #endif #if PHP_VERSION_ID < 50399 /* initializing properties in obejct (object_properties_init was added in PHP 5.4) */ #define PHPC_OBJ_PROPERTIES_INIT(_zo, _class_type) \ do { \ zval *_phpc_tmp; \ zend_hash_copy((*(_zo)).properties, \ &(_class_type)->default_properties, \ (copy_ctor_func_t) zval_add_ref, \ (void *) &_phpc_tmp, \ sizeof(zval *)); \ } while(0) /* write property */ #define PHPC_OBJ_STD_WRITE_PROPERTY(_obj, _member, _value) \ Z_OBJ_HT_P(_obj)->write_property(_obj, _member, _value TSRMLS_CC) #else #define PHPC_OBJ_PROPERTIES_INIT object_properties_init #define PHPC_OBJ_STD_WRITE_PROPERTY(_obj, _member, _value) \ zend_std_write_property(_obj, _member, _value, NULL TSRMLS_CC) #endif /* common fcall macros */ #define PHPC_FCALL_PARAMS_NAME(_pname) _phpc_fcall_params__ ## _pname /* integer conversions */ #define PHPC_CONVERT_NUMBER(_pn, _n, _exc_over, _exc_under, _type_from, _type_to, _max, _min) \ if (_pn > (_type_from) _max) { \ _exc_over; \ } else if (_pn < (_type_from) _min) { \ _exc_under; \ } \ _n = (_type_to) _pn #define PHPC_CONVERT_NUMBER_SIGNED(_pn, _n, _exc_over, _type_from, _type_to, _max) \ if (_pn > (_type_from) _max) { \ _exc_over; \ } \ _n = (_type_to) _pn #define PHPC_LONG_TO_INT_EX2(_plv, _lv, _exc_over, _exc_under) \ PHPC_CONVERT_NUMBER(_plv, _lv, _exc_over, _exc_under, long, int, INT_MAX, INT_MIN) #define PHPC_LONG_TO_INT_EX(_plv, _lv, _exc) \ PHPC_LONG_TO_INT_EX2(_plv, _lv, _exc, _exc) #define PHPC_LONG_TO_INT(_plv, _lv) \ PHPC_LONG_TO_INT_EX2(_plv, _lv, _lv = INT_MAX, _lv = INT_MIN) #if PHP_MAJOR_VERSION < 8 /* PHP 5 and 7 */ /* object */ #define phpc_obj_t zval #define PHPC_OBJ_TO_POBJ(_obj) Z_OBJ_P(_obj) #define PHPC_OBJ_FOR_PROP(_obj) (_obj) #define PHPC_OBJ_HANDLER_COMPARE_NAME compare_objects #define PHPC_FCALL_FCI_INIT(_fci, _callback, _count, _no_separ) \ do { \ (_fci).params = PHPC_FCALL_PARAMS_NAME(_callback); \ (_fci).param_count = (_count); \ (_fci).no_separation = (_no_separ); \ } while (0) #else /* PHP 8 */ /* object */ #define phpc_obj_t zend_object #define PHPC_OBJ_TO_POBJ(_obj) (_obj) #define PHPC_OBJ_FOR_PROP(_obj) Z_OBJ_P(_obj) #define PHPC_OBJ_HANDLER_COMPARE_NAME compare /* fcall */ #define PHPC_FCALL_FCI_INIT(_fci, _callback, _count, _no_separ) \ do { \ (_fci).params = PHPC_FCALL_PARAMS_NAME(_callback); \ (_fci).param_count = (_count); \ } while (0) /* ZTS */ #define TSRMLS_D void #define TSRMLS_DC #define TSRMLS_C #define TSRMLS_CC #define TSRMLS_FETCH() #endif #define PHPC_OBJ_STD_GET_PROPERTIES(_obj) \ zend_std_get_properties((_obj) TSRMLS_CC) #if PHP_MAJOR_VERSION == 5 /* MODULE */ #ifdef ZTS #define PHPC_MODULE_GLOBALS_ACCESSOR(_module, _v) \ TSRMG(_module ## _globals_id, zend_ ## _module ## _globals *, _v) #else #define PHPC_MODULE_GLOBALS_ACCESSOR(_module, _v) \ (_module ## _globals._v) #endif #define PHPC_MODULE_HAS_THREAD_CACHE 0 /* INTEGER */ /* long type */ typedef long phpc_long_t; /* unsigned long type */ typedef unsigned long phpc_ulong_t; /* offset type */ typedef off_t phpc_off_t; /* string length type */ typedef int phpc_str_size_t; #define PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc_over, _exc_under) \ _lv = _plv #define PHPC_LONG_TO_LONG_EX(_plv, _lv, _exc) \ _lv = _plv #define PHPC_LONG_TO_LONG(_plv, _lv) \ _lv = _plv #define PHPC_SIZE_TO_LONG_EX PHPC_LONG_TO_LONG_EX #define PHPC_SIZE_TO_LONG PHPC_LONG_TO_LONG #define PHPC_SIZE_TO_INT_EX PHPC_LONG_TO_LONG_EX #define PHPC_SIZE_TO_INT PHPC_LONG_TO_LONG /* STRING */ /* accessor and convertor macros */ #define PHPC_STR_VAL(_name) _name##__val #define PHPC_STR_LEN(_name) _name##__len #define PHPC_STR_LEN_FMT "d" #define PHPC_STR_LEN_UNUSED(_name) (void) PHPC_STR_LEN(_name) #define PHPC_STR_LEN_FROM_VAL(_name) strlen(PHPC_STR_VAL(_name)) #define PHPC_STR_LEN_DECLARE(_name) int PHPC_STR_LEN(_name) #define PHPC_STR_LEN_FETCH(_name) PHPC_STR_LEN(_name) = PHPC_STR_LEN_FROM_VAL(_name) #define PHPC_STR_LEN_DECLARE_AND_FETCH(_name) int PHPC_STR_LEN_FETCH(_name) #define PHPC_STR_EXISTS(_name) PHPC_STR_VAL(_name) #define PHPC_STR_DECLARE(_name) char *PHPC_STR_VAL(_name); int PHPC_STR_LEN(_name) #define PHPC_STR_ARG(_name) char *PHPC_STR_VAL(_name), int PHPC_STR_LEN(_name) #define PHPC_STR_ARG_VAL(_name) char *PHPC_STR_VAL(_name) #define PHPC_STR_ARG_PTR(_name) char **PHPC_STR_VAL(_name), int *PHPC_STR_LEN(_name) #define PHPC_STR_ARG_PTR_VAL(_name) char **PHPC_STR_VAL(_name) #define PHPC_STR_PASS(_name) PHPC_STR_VAL(_name), PHPC_STR_LEN(_name) #define PHPC_STR_PASS_VAL(_name) PHPC_STR_VAL(_name) #define PHPC_STR_PASS_PTR(_name) &PHPC_STR_VAL(_name), &PHPC_STR_LEN(_name) #define PHPC_STR_PASS_PTR_VAL(_name) &PHPC_STR_VAL(_name) #define PHPC_STR_DEREF_VAL(_name) *PHPC_STR_VAL(_name) #define PHPC_STR_FROM_PTR_STR(_str, _strp) \ PHPC_STR_VAL(_str) = *PHPC_STR_VAL(_strp); \ PHPC_STR_LEN(_str) = *PHPC_STR_LEN(_strp) #define PHPC_STR_FROM_PTR_VAL(_str, _strpv) \ PHPC_STR_VAL(_str) = *PHPC_STR_VAL(_strpv); \ PHPC_STR_LEN(_str) = strlen(*PHPC_STR_VAL(_strpv)) #define PHPC_STR_FROM_ZVAL(_str, _zv) \ PHPC_STR_VAL(_str) = Z_STRVAL(_zv); \ PHPC_STR_LEN(_str) = Z_STRLEN(_zv) #define PHPC_STR_FROM_PZVAL(_str, _pzv) \ PHPC_STR_VAL(_str) = Z_STRVAL_P(_pzv); \ PHPC_STR_LEN(_str) = Z_STRLEN_P(_pzv) #define PHPC_STR_RETURN(_name) \ RETURN_STRINGL(PHPC_STR_VAL(_name), PHPC_STR_LEN(_name), 0) /* wrapper macros */ #define PHPC_STR_INIT(_name, _cstr, _len) do { \ PHPC_STR_VAL(_name) = emalloc(_len + 1); \ memcpy(PHPC_STR_VAL(_name), _cstr, _len); \ PHPC_STR_VAL(_name)[_len] = 0; \ PHPC_STR_LEN(_name) = _len; \ } while (0) #define PHPC_STR_ALLOC(_name, _len) do { \ PHPC_STR_VAL(_name) = emalloc(_len + 1); \ PHPC_STR_LEN(_name) = _len; \ } while (0) #define PHPC_STR_REALLOC(_name, _len) do { \ PHPC_STR_VAL(_name) = erealloc(PHPC_STR_VAL(_name), _len + 1); \ PHPC_STR_LEN(_name) = _len; \ } while (0) #define PHPC_STR_RELEASE(_name) efree(PHPC_STR_VAL(_name)) /* C string */ #define PHPC_CSTRL_RETURN(_name, _len) RETURN_STRINGL(_name, _len, 1) #define PHPC_CSTR_RETURN(_name) RETURN_STRING(_name, 1) #define PHPC_CSTRL_RETVAL(_name, _len) RETVAL_STRINGL(_name, _len, 1) #define PHPC_CSTR_RETVAL(_name) RETVAL_STRING(_name, 1) /* ZSTR */ #define PHPC_ZSTR_VAL(_name) _name /* Smart string */ #if defined(PHPC_SMART_STR_INCLUDE) || defined(PHPC_SMART_CSTR_INCLUDE) #include "ext/standard/php_smart_str.h" #ifdef PHPC_SMART_CSTR_INCLUDE /* smart_str for C string has been renamed in PHP 7 so we have to wrap it */ #define phpc_smart_cstr smart_str #define phpc_smart_cstr_alloc smart_str_alloc #define phpc_smart_cstr_free smart_str_free #define phpc_smart_cstr_append smart_str_append #define phpc_smart_cstr_appends smart_str_appends #define phpc_smart_cstr_appendl smart_str_appendl #define phpc_smart_cstr_appendc smart_str_appendc #define phpc_smart_cstr_append_long smart_str_append_long #define phpc_smart_cstr_append_unsigned smart_str_append_unsigned #define phpc_smart_cstr_0 smart_str_0 #endif /* PHPC_SMART_CSTR_INCLUDE */ #endif /* PHPC_SMART_STR_INCLUDE || PHPC_SMART_CSTR_INCLUDE */ /* RESOURCE */ typedef zend_rsrc_list_entry phpc_res_entry_t; typedef long phpc_res_value_t; #define PHPC_RES_REGISTER(_entry, _type) \ zend_list_insert(_entry, _type TSRMLS_CC) #define PHPC_RES_FETCH(_pz_res, _res_type_name, _res_type) \ zend_fetch_resource(&(_pz_res) TSRMLS_CC, -1, _res_type_name, NULL, 1, _res_type) #define PHPC_RES_FETCH2(_pz_res, _res_type_name, _res_type_1, _res_type_2) \ zend_fetch_resource(&(_pz_res) TSRMLS_CC, -1, _res_type_name, NULL, 2, _res_type_1, _res_type_2) #define PHPC_RES_DELETE(_pz_res) \ zend_list_delete(Z_LVAL_P(_pz_res)) #define PHPC_RES_CLOSE PHPC_RES_DELETE /* resource to zval */ #define PHPC_RES_PZVAL(_res, _pzv) \ ZVAL_RESOURCE(_pzv, _res) #define PHPC_RES_RETVAL RETVAL_RESOURCE #define PHPC_RES_RETURN RETURN_RESOURCE /* OBJECT */ #define PHPC_CLASS_REGISTER_EX(_orig_class_entry, _parent_ce, _parent_name) \ zend_register_internal_class_ex(&_orig_class_entry, _parent_ce, _parent_name TSRMLS_CC) #define PHPC_CLASS_REGISTER(_orig_class_entry) \ zend_register_internal_class(&_orig_class_entry TSRMLS_CC) /* struct spec */ #define PHPC_OBJ_STRUCT_MEMBER_FIRST zend_object std; #define PHPC_OBJ_STRUCT_MEMBER_LAST #define PHPC_OBJ_STRUCT_BEGIN(_name) \ PHPC_OBJ_STRUCT_NAME(_name) { PHPC_OBJ_STRUCT_MEMBER_FIRST #define PHPC_OBJ_STRUCT_END() \ PHPC_OBJ_STRUCT_MEMBER_LAST }; /* object convertors */ #define PHPC_OBJ_FROM_ZOBJ(_name, _object) \ (PHPC_OBJ_STRUCT_NAME(_name) *) _object #define PHPC_OBJ_FROM_ZVAL(_name, _zv) \ (PHPC_OBJ_STRUCT_NAME(_name) *) zend_object_store_get_object(_zv TSRMLS_CC) #define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZVAL /* create_ex object handler helper */ #define PHPC_OBJ_HANDLER_CREATE_EX(_name) \ PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(zend_object_value, _name, create_ex) \ (zend_class_entry *PHPC_CLASS_TYPE, PHPC_OBJ_STRUCT_NAME(_name) **_phpc_objptr TSRMLS_DC) #define PHPC_OBJ_HANDLER_CREATE_EX_IS_NEW() (_phpc_objptr == NULL) #define PHPC_OBJ_HANDLER_CREATE_EX_DECLARE() zend_object_value _phpc_retval #define PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name) \ ecalloc(1, sizeof(PHPC_OBJ_STRUCT_NAME(_name))); #define PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(_intern) \ do { \ if (_phpc_objptr) { \ *_phpc_objptr = _intern; \ } \ zend_object_std_init(&_intern->std, PHPC_CLASS_TYPE TSRMLS_CC); \ PHPC_OBJ_PROPERTIES_INIT(&_intern->std, PHPC_CLASS_TYPE); \ } while(0) #define PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, _intern) \ do { \ _phpc_retval.handle = zend_objects_store_put((_intern), \ (zend_objects_store_dtor_t) zend_objects_destroy_object, \ (zend_objects_free_object_storage_t) PHPC_OBJ_GET_HANDLER_FCE(_name, free), \ NULL TSRMLS_CC); \ _phpc_retval.handlers = &PHPC_OBJ_GET_HANDLER_VAR_NAME(_name); \ return _phpc_retval; \ } while(0) /* create object handler */ #define PHPC_OBJ_HANDLER_CREATE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object_value, _name, create) \ (zend_class_entry *PHPC_CLASS_TYPE TSRMLS_DC) #define PHPC_OBJ_HANDLER_CREATE_RETURN(_name) \ return PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(PHPC_CLASS_TYPE, NULL TSRMLS_CC) /* clone object handler */ #define PHPC_OBJ_HANDLER_CLONE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object_value, _name, clone)(phpc_obj_t *PHPC_SELF TSRMLS_DC) #define PHPC_OBJ_HANDLER_CLONE_DECLARE() zend_object_value _phpc_retval #define PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, _new_obj, _old_obj) \ do { \ _phpc_retval = PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(_old_obj->std.ce, &_new_obj TSRMLS_CC); \ zend_objects_clone_members(&_new_obj->std, _phpc_retval, &_old_obj->std, Z_OBJ_HANDLE_P(PHPC_SELF) TSRMLS_CC); \ } while(0) #define PHPC_OBJ_HANDLER_CLONE_RETURN_EX(_new_obj) return _phpc_retval /* free object handler */ #define PHPC_OBJ_HANDLER_FREE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(void, _name, free)(void *_phpc_object TSRMLS_DC) #define PHPC_OBJ_HANDLER_FREE_DTOR(_intern) \ do { \ zend_object_std_dtor(&(_intern)->std TSRMLS_CC); \ efree(_intern); \ } while(0) /* compare object handler */ #define PHPC_OBJ_HANDLER_COMPARE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(int, _name, compare)(zval *_phpc_obj1, zval *_phpc_obj2 TSRMLS_DC) #define PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, _id, _obj) \ PHPC_OBJ_STRUCT_DECLARE(_name, _obj) = PHPC_OBJ_FROM_ZVAL(_name, _phpc_obj ## _id) /* handler setters */ #define PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(_handlers, _name) PHPC_NOOP #define PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(_handlers, _name) PHPC_NOOP /* read propery */ #define PHPC_READ_PROPERTY_RV_NAME #define PHPC_READ_PROPERTY_RV_DECLARE PHPC_NOOP #define PHPC_READ_PROPERTY(_scope, _object, _name, _name_len, _silent) \ zend_read_property(_scope, _object, _name, _name_len, _silent TSRMLS_CC) /* HASH */ /* apply count */ #define PHPC_HASH_HAS_APPLY_COUNT(_ht) (_ht->nApplyCount > 0) #define PHPC_HASH_GET_APPLY_COUNT(_ht) _ht->nApplyCount #define PHPC_HASH_INC_APPLY_COUNT(_ht) _ht->nApplyCount++ #define PHPC_HASH_DEC_APPLY_COUNT(_ht) _ht->nApplyCount-- #define PHPC_HASH_APPLY_PROTECTION(_ht) 1 /* add ptr */ #define PHPC_HASH_INDEX_ADD_PTR(_ht, _idx, _ptr, _ptr_size) \ zend_hash_index_update(_ht, _idx, _ptr, _ptr_size, NULL) #define PHPC_HASH_STR_ADD_PTR(_ht, _str, _ptr, _ptr_size) \ zend_hash_add(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, _ptr, _ptr_size, NULL) #define PHPC_HASH_CSTRL_ADD_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ zend_hash_add(_ht, _cstr_value, (_cstr_len) + 1, _ptr, _ptr_size, NULL) #define PHPC_HASH_CSTR_ADD_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ zend_hash_add(_ht, _cstr_value, strlen(_cstr_value) + 1, _ptr, _ptr_size, NULL) /* add */ #define PHPC_HASH_INDEX_ADD(_ht, _idx, _pzv) \ zend_hash_index_update(_ht, _idx, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_STR_ADD(_ht, _str, _pzv) \ zend_hash_add(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_CSTRL_ADD(_ht, _cstr_value, _cstr_len, _pzv) \ zend_hash_add(_ht, _cstr_value, (_cstr_len) + 1, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_CSTR_ADD(_ht, _cstr_value, _pzv) \ zend_hash_add(_ht, _cstr_value, strlen(_cstr_value) + 1, &_pzv, sizeof(_pzv), NULL) /* next insert */ #define PHPC_HASH_NEXT_INDEX_INSERT_PTR(_ht, _ptr, _ptr_size) \ zend_hash_next_index_insert(_ht, _ptr, _ptr_size, NULL) #define PHPC_HASH_NEXT_INDEX_INSERT(_ht, _pzv) \ zend_hash_next_index_insert(_ht, _pzv, sizeof(_pzv), NULL) /* update ptr */ #define PHPC_HASH_INDEX_UPDATE_PTR(_ht, _idx, _ptr, _ptr_size) \ zend_hash_index_update(_ht, _idx, _ptr, _ptr_size, NULL) #define PHPC_HASH_STR_UPDATE_PTR(_ht, _str, _ptr, _ptr_size) \ zend_hash_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, _ptr, _ptr_size, NULL) #define PHPC_HASH_CSTRL_UPDATE_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ zend_hash_update(_ht, _cstr_value, (_cstr_len) + 1, _ptr, _ptr_size, NULL) #define PHPC_HASH_CSTR_UPDATE_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ zend_hash_update(_ht, _cstr_value, strlen(_cstr_value) + 1, _ptr, _ptr_size, NULL) /* update */ #define PHPC_HASH_INDEX_UPDATE(_ht, _idx, _pzv) \ zend_hash_index_update(_ht, _idx, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_STR_UPDATE(_ht, _str, _pzv) \ zend_hash_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_CSTRL_UPDATE(_ht, _cstr_value, _cstr_len, _pzv) \ zend_hash_update(_ht, _cstr_value, (_cstr_len) + 1, &_pzv, sizeof(_pzv), NULL) #define PHPC_HASH_CSTR_UPDATE(_ht, _cstr_value, _pzv) \ zend_hash_update(_ht, _cstr_value, strlen(_cstr_value) + 1, &_pzv, sizeof(_pzv), NULL) /* delete */ #define PHPC_HASH_INDEX_DELETE(_ht, _idx) \ zend_hash_index_del(_ht, _idx) #define PHPC_HASH_STR_DELETE(_ht, _str) \ zend_hash_del(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1) #define PHPC_HASH_CSTRL_DELETE(_ht, _cstr_value, _cstr_len) \ zend_hash_del(_ht, _cstr_value, (_cstr_len) + 1) #define PHPC_HASH_CSTR_DELETE(_ht, _cstr_value) \ zend_hash_del(_ht, _cstr_value, strlen(_cstr_value) + 1) /* exists */ #define PHPC_HASH_INDEX_EXISTS(_ht, _idx) \ zend_hash_index_exists(_ht, _idx) #define PHPC_HASH_STR_EXISTS(_ht, _str) \ zend_hash_exists(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1) #define PHPC_HASH_CSTRL_EXISTS(_ht, _cstr_value, _cstr_len) \ zend_hash_exists(_ht, _cstr_value, (_cstr_len) + 1) #define PHPC_HASH_CSTR_EXISTS(_ht, _cstr_value) \ zend_hash_exists(_ht, _cstr_value, strlen(_cstr_value) + 1) /* find */ #define PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv) \ zend_hash_index_find(_ht, _idx, (void **) &_ppv) #define PHPC_HASH_STR_FIND(_ht, _str, _ppv) \ zend_hash_find(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, (void **) &_ppv) #define PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv) \ zend_hash_find(_ht, _cstr_value, (_cstr_len) + 1, (void **) &_ppv) #define PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv) \ zend_hash_find(_ht, _cstr_value, strlen(_cstr_value) + 1, (void **) &_ppv) /* find ptr */ #define PHPC_HASH_STR_FIND_PTR PHPC_HASH_STR_FIND #define PHPC_HASH_INDEX_FIND_PTR PHPC_HASH_INDEX_FIND #define PHPC_HASH_CSTRL_FIND_PTR PHPC_HASH_CSTRL_FIND #define PHPC_HASH_CSTR_FIND_PTR PHPC_HASH_CSTR_FIND /* not found value */ #define PHPC_HASH_NOT_FOUND FAILURE /* key and data getter */ #define PHPC_HASH_GET_CURRENT_KEY_EX(_ht, _str, _num_index, _pos) \ do { \ unsigned int _phpc_current_key_len; \ zend_hash_get_current_key_ex(_ht, &PHPC_STR_VAL(_str), \ &_phpc_current_key_len, &_num_index, 0, _pos); \ PHPC_STR_LEN(_str) = _phpc_current_key_len - 1; \ } while(0) #define PHPC_HASH_GET_CURRENT_DATA_EX(_ht, _val, _pos) \ zend_hash_get_current_data_ex(_ht, (void **) &(_val), _pos) #define PHPC_HASH_GET_CURRENT_KEY(_ht, _str, _num_index) \ zend_hash_get_current_key(_ht, &PHPC_STR_VAL(_str), &_num_index, 0) #define PHPC_HASH_GET_CURRENT_DATA(_ht, _val) \ zend_hash_get_current_data(_ht, (void **) &(_val)) /* copy */ #define PHPC_HASH_COPY_EX(_target, _source, _copy_ctr) \ zend_hash_copy(_target, _source, NULL, NULL, sizeof(zval *)) /* key result constant has been renamed in 5.4 */ #if PHP_VERSION_ID < 50399 #define _PHPC_HASH_KEY_NON_EXISTENT HASH_KEY_NON_EXISTANT #else #define _PHPC_HASH_KEY_NON_EXISTENT HASH_KEY_NON_EXISTENT #endif /* iteration for each element */ #define PHPC_HASH_FOREACH_KEY(_ht, _h, _key) do { \ HashPosition _pos; \ uint _str_length; \ int _key_type; \ for (zend_hash_internal_pointer_reset_ex((_ht), &_pos); \ (_key_type = zend_hash_get_current_key_ex( \ (_ht), &PHPC_STR_VAL(_key), &_str_length, &_h, 0, &_pos)) != _PHPC_HASH_KEY_NON_EXISTENT; \ zend_hash_move_forward_ex((_ht), &_pos) ) { \ if (_key_type == HASH_KEY_IS_STRING) { \ PHPC_STR_LEN(_key) = (int) _str_length - 1; \ } else { \ PHPC_STR_VAL(_key) = NULL; \ PHPC_STR_LEN(_key) = 0; \ } #define PHPC_HASH_FOREACH_VAL(_ht, _ppv) do { \ HashPosition _pos; \ for (zend_hash_internal_pointer_reset_ex((_ht), &_pos); \ zend_hash_get_current_data_ex((_ht), (void **) &(_ppv), &_pos) == SUCCESS; \ zend_hash_move_forward_ex((_ht), &_pos) ) { #define PHPC_HASH_FOREACH_VAL_IND PHPC_HASH_FOREACH_VAL #define _PHPC_HASH_FOREACH_KEY_VAL(_ht, _ph, _key, _ppv, _use_h) \ PHPC_HASH_FOREACH_VAL(_ht, _ppv) \ int _key_type; \ uint _str_length; \ ulong _num_index, *_pnum_index; \ if (_use_h) { \ _pnum_index = _ph; \ } else { \ _pnum_index = &_num_index; \ } \ _key_type = zend_hash_get_current_key_ex(_ht, &PHPC_STR_VAL(_key), &_str_length, _pnum_index, 0, &_pos); \ if (_key_type == HASH_KEY_IS_STRING) { \ PHPC_STR_LEN(_key) = (int) _str_length - 1; \ } else { \ PHPC_STR_VAL(_key) = NULL; \ PHPC_STR_LEN(_key) = 0; \ } #define PHPC_HASH_FOREACH_KEY_VAL(_ht, _h, _key, _ppv) \ _PHPC_HASH_FOREACH_KEY_VAL(_ht, &_h, _key, _ppv, 1) #define PHPC_HASH_FOREACH_KEY_VAL_IND PHPC_HASH_FOREACH_KEY_VAL #define PHPC_HASH_FOREACH_STR_KEY_VAL(_ht, _key, _ppv) \ _PHPC_HASH_FOREACH_KEY_VAL(_ht, NULL, _key, _ppv, 0) #define PHPC_HASH_FOREACH_STR_KEY_VAL_IND PHPC_HASH_FOREACH_STR_KEY_VAL #define PHPC_HASH_FOREACH_END() } } while (0) /* hash to zval */ #define PHPC_HASH_PZVAL(_ht, _pzv) \ do { \ Z_ARRVAL_P(_pzv) = _ht; \ Z_TYPE_P(_pzv) = IS_ARRAY; \ } while(0) #define PHPC_HASH_RETVAL(_ht) \ PHPC_HASH_PZVAL(_ht, return_value) #define PHPC_HASH_RETURN(_ht) \ do { \ PHPC_HASH_RETVAL(_ht); \ return; \ } while(0) /* SYMTABLE */ /* update*/ #define PHPC_SYMTABLE_UPDATE(_ht, _str, _pzv) \ zend_symtable_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) /* ARRAY */ #define PHPC_ARRAY_ADD_ASSOC_NULL_EX(_arr, _key, _key_len) \ add_assoc_null_ex(_arr, _key, (_key_len) + 1) #define PHPC_ARRAY_ADD_ASSOC_BOOL_EX(_arr, _key, _key_len, _b) \ add_assoc_bool_ex(_arr, _key, (_key_len) + 1, _b) #define PHPC_ARRAY_ADD_ASSOC_LONG_EX(_arr, _key, _key_len, _n) \ add_assoc_long_ex(_arr, _key, (_key_len) + 1, _n) #define PHPC_ARRAY_ADD_ASSOC_RESOURCE_EX(_arr, _key, _key_len, _r) \ add_assoc_resource_ex(_arr, _key, (_key_len) + 1, _r) #define PHPC_ARRAY_ADD_ASSOC_DOUBLE_EX(_arr, _key, _key_len, _d) \ add_assoc_double_ex(_arr, _key, (_key_len) + 1, _d) #define PHPC_ARRAY_ADD_ASSOC_STR_EX(_arr, _key, _key_len, _str) \ add_assoc_stringl_ex(_arr, _key, (_key_len) + 1, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #define PHPC_ARRAY_ADD_ASSOC_CSTR_EX(_arr, _key, _key_len, _cstr) \ add_assoc_string_ex(_arr, _key, (_key_len) + 1, _cstr, 1) #define PHPC_ARRAY_ADD_ASSOC_CSTRL_EX(_arr, _key, _key_len, _cstr, _cstr_len) \ add_assoc_stringl_ex(_arr, _key, (_key_len) + 1, _cstr, _cstr_len, 1) #define PHPC_ARRAY_ADD_ASSOC_ZVAL_EX(_arr, _key, _key_len, _zv) \ add_assoc_zval_ex(_arr, _key, (_key_len) + 1, _zv) #define PHPC_ARRAY_ADD_ASSOC_VAL_EX(_arr, _key, _key_len, _pv) \ add_assoc_zval_ex(_arr, _key, (_key_len) + 1, _pv) #define PHPC_ARRAY_ADD_ASSOC_STR(_arr, _key, _str) \ add_assoc_stringl(_arr, _key, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #define PHPC_ARRAY_ADD_ASSOC_CSTR(_arr, _key, _cstr) \ add_assoc_string(_arr, _key, _cstr, 1) #define PHPC_ARRAY_ADD_ASSOC_CSTRL(_arr, _key, _cstr, _cstr_len) \ add_assoc_stringl(_arr, _key, _cstr, _cstr_len, 1) #define PHPC_ARRAY_ADD_ASSOC_VAL add_assoc_zval #define PHPC_ARRAY_ADD_INDEX_STR(_arr, _idx, _str) \ add_index_stringl(_arr, _idx, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #define PHPC_ARRAY_ADD_INDEX_CSTR(_arr, _idx, _cstr) \ add_index_string(_arr, _idx, _cstr, 1) #define PHPC_ARRAY_ADD_INDEX_CSTRL(_arr, _idx, _cstr, _cstr_len) \ add_index_stringl(_arr, _idx, _cstr, _cstr_len, 1) #define PHPC_ARRAY_ADD_INDEX_VAL add_index_zval #define PHPC_ARRAY_ADD_NEXT_INDEX_STR(_arr, _str) \ add_next_index_stringl(_arr, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #define PHPC_ARRAY_ADD_NEXT_INDEX_CSTR(_arr, _cstr) \ add_next_index_string(_arr, _cstr, 1) #define PHPC_ARRAY_ADD_NEXT_INDEX_CSTRL(_arr, _cstr, _cstr_len) \ add_next_index_stringl(_arr, _cstr, _cstr_len, 1) #define PHPC_ARRAY_ADD_NEXT_INDEX_VAL add_next_index_zval /* FCALL */ #define _PHPC_FCALL_VARS_NAME(_pname) _phpc_fcall_vars__ ## _pname #define PHPC_FCALL_PARAMS_DECLARE(_pname, _count) \ int _phpc_fcall_params_count = _count; \ zval *_PHPC_FCALL_VARS_NAME(_pname)[_count]; \ zval **PHPC_FCALL_PARAMS_NAME(_pname)[_count] #define PHPC_FCALL_PARAMS_INIT(_pname) \ do { \ int _idx; \ for (_idx = 0; _idx < _phpc_fcall_params_count; _idx++) \ PHPC_FCALL_PARAMS_NAME(_pname)[_idx] = &_PHPC_FCALL_VARS_NAME(_pname)[_idx]; \ } while(0) #define PHPC_FCALL_PARAM_PZVAL(_pname, _idx) \ _PHPC_FCALL_VARS_NAME(_pname)[_idx] #define PHPC_FCALL_PARAM_VAL(_pname, _idx) \ _PHPC_FCALL_VARS_NAME(_pname)[_idx] #define PHPC_FCALL_PARAM_UNDEF(_pname, _idx) \ ZVAL_NULL(PHPC_FCALL_PARAM_PZVAL(_pname, _idx)) #define PHPC_FCALL_RETVAL(_fci, _pv) \ (_fci).retval_ptr_ptr = &(_pv) /* ZVAL */ typedef zval * phpc_val; #define PHPC_TYPE Z_TYPE_P #define PHPC_TYPE_P Z_TYPE_PP #define PHPC_LVAL Z_LVAL_P #define PHPC_LVAL_P Z_LVAL_PP #define PHPC_DVAL Z_DVAL_P #define PHPC_DVAL_P Z_DVAL_PP #define PHPC_STRVAL Z_STRVAL_P #define PHPC_STRVAL_P Z_STRVAL_PP #define PHPC_STRLEN Z_STRLEN_P #define PHPC_STRLEN_P Z_STRLEN_PP #define PHPC_ARRVAL Z_ARRVAL_P #define PHPC_ARRVAL_P Z_ARRVAL_PP #define PHPC_OBJ_HT Z_OBJ_HT_P #define PHPC_OBJ_HT_P Z_OBJ_HT_PP #define PHPC_OBJ_HANDLER Z_OBJ_HANDLER_P #define PHPC_OBJ_HANDLER_P Z_OBJ_HANDLER_PP #define PHPC_OBJ_HANDLE Z_OBJ_HANDLE_P #define PHPC_OBJ_HANDLE_P Z_OBJ_HANDLE_PP #define PHPC_OBJCE Z_OBJCE_P #define PHPC_OBJCE_P Z_OBJCE_PP #define PHPC_OBJPROP Z_OBJPROP_P #define PHPC_OBJPROP_P Z_OBJPROP_PP #define PHPC_OBJDEBUG Z_OBJDEBUG_P #define PHPC_OBJDEBUG_P Z_OBJDEBUG_PP #define PHPC_REFCOUNTED(_zv) 1 #define PHPC_REFCOUNTED_P(_pzv) 1 #define PHPC_PZVAL_CAST_TO_PVAL(_pzv) &_pzv #define PHPC_VAL_CAST_TO_ZVAL(_pv) *(_pv) #define PHPC_VAL_CAST_TO_PZVAL(_pv) _pv #define PHPC_PVAL_CAST_TO_PZVAL(_ppv) *(_ppv) #define PHPC_VAL_TO_ZVAL(_pv, _zv) _zv = *(_pv) #define PHPC_VAL_TO_PZVAL(_pv, _zv) _zv = _pv #define PHPC_PVAL_TO_PZVAL(_ppv, _zv) _zv = *(_ppv) #define PHPC_VAL_MAKE MAKE_STD_ZVAL #define PHPC_VAL_FREE FREE_ZVAL #define PHPC_VAL_UNDEF(_pv) _pv = NULL #define PHPC_VAL_ISUNDEF(_pv) _pv == NULL #define PHPC_VAL_COPY(_pv, _zv) ZVAL_ZVAL(_pv, _zv, 1, 0) #define PHPC_VAL_ASSIGN(_pv, _zv) _pv = _zv #define PHPC_PZVAL_MAKE MAKE_STD_ZVAL #define PHPC_PZVAL_FREE FREE_ZVAL #define PHPC_PZVAL_SET(_pv, _zv) ZVAL_ZVAL(_pv, _zv, 0, 0) #define PHPC_PVAL_DEREF(_pv) PHPC_NOOP #define PHPC_PZVAL_DEREF(_pv) PHPC_NOOP #define PHPC_PZVAL_COPY_INIT INIT_PZVAL_COPY #define PHPC_PZVAL_COPY(_pzv_dst, _pzv_src) \ *_pzv_dst = *_pzv_src #define PHPC_VAL_NEW_STR(_pv, _str) \ ZVAL_STRINGL(_pv, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #define PHPC_VAL_STR PHPC_VAL_NEW_STR #define PHPC_VAL_CSTR(_pv, _cstr) \ ZVAL_STRING(_pv, _cstr, 1) #define PHPC_VAL_CSTRL(_pv, _cstr, _cstr_len) \ ZVAL_STRINGL(_pv, _cstr, _cstr_len, 1) #define PHPC_PZVAL_NEW_STR PHPC_VAL_NEW_STR #define PHPC_PZVAL_STR PHPC_VAL_STR #define PHPC_PZVAL_CSTR PHPC_VAL_CSTR #define PHPC_PZVAL_CSTRL PHPC_VAL_CSTRL #define PHPC_ZVAL_COPY(_zv_dst, _zv_src) \ _zv_dst = _zv_src #define PHPC_ZVAL_NEW_STR(_zv, _str) \ PHPC_VAL_STR(&_zv, _str) #define PHPC_ZVAL_STR PHPC_ZVAL_NEW_STR #define PHPC_ZVAL_CSTR(_zv, _cstr) \ PHPC_VAL_CSTR(&_zv, _cstr) #define PHPC_ZVAL_CSTRL(_zv, _cstr, _cstr_len) \ PHPC_VAL_CSTRL(&_zv, _cstr, _cstr_len) #define PHPC_ZVAL_IS_TRUE(_zv) \ (Z_TYPE(_zv) == IS_BOOL && Z_BVAL(_zv)) #define PHPC_ZVAL_IS_FALSE(_zv) \ (Z_TYPE(_zv) == IS_BOOL && !Z_BVAL(_zv)) #define PHPC_VAL_IS_TRUE(_pv) PHPC_ZVAL_IS_TRUE(*_pv) #define PHPC_VAL_IS_FALSE(_pv) PHPC_ZVAL_IS_FALSE(*_pv) /* Function end */ #if (PHP_MINOR_VERSION == 3 && PHP_RELEASE_VERSION >= 7) || (PHP_MINOR_VERSION >= 4) #define PHPC_FE_END PHP_FE_END #else #define PHPC_FE_END {NULL,NULL,NULL} #endif /* ZPP */ /* path flag */ #if PHP_VERSION_ID < 50399 #define PHPC_ZPP_PATH_FLAG "s" #else #define PHPC_ZPP_PATH_FLAG "p" #endif /* args */ #define PHPC_ZPP_ARGS_DECLARE() \ int _phpc_zpp_args_count = 0; \ zval ***_phpc_zpp_args_array #if PHP_API_VERSION < 20090626 #define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ do { \ const char *_phpc_zpp_args_type_str = #_flag; \ _phpc_zpp_args_count = _num_args; \ _phpc_zpp_args_array = (zval ***) safe_emalloc(_num_args, sizeof (zval **), 0); \ if ((_phpc_zpp_args_type_str[0] == '+' && _num_args == 0) || \ zend_get_parameters_array_ex(_phpc_zpp_args_count, _phpc_zpp_args_array) == FAILURE) { \ efree(_phpc_zpp_args_array); \ zend_wrong_param_count(TSRMLS_C); \ _return; \ } \ } while (0) #else #define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ do { \ if (zend_parse_parameters(_num_args TSRMLS_CC, #_flag, \ &_phpc_zpp_args_array, &_phpc_zpp_args_count) == FAILURE) { \ _return; \ } \ } while(0) #endif #define PHPC_ZPP_ARGS_GET_PVAL(_arg_pos) \ _phpc_zpp_args_array[_arg_pos] #define PHPC_ZPP_ARGS_FREE() \ if (_phpc_zpp_args_count > 0) \ efree(_phpc_zpp_args_array) /* STREAM */ #if PHP_VERSION_ID < 50600 typedef char phpc_stream_opener_char_t; #else typedef const char phpc_stream_opener_char_t; #endif #define PHPC_STREAM_WRAPPERDATA_ALLOC(stream) MAKE_STD_ZVAL(stream->wrapperdata) #define PHPC_STREAM_WRAPPERDATA_ISSET(stream) stream->wrapperdata #define PHPC_STREAM_WRAPPERDATA_UNSET(stream) \ do { \ zval_ptr_dtor(&stream->wrapperdata); \ stream->wrapperdata = NULL; \ } while(0) #define PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv) \ php_stream_context_get_option(_ctx, _wrappername, _optionname, &_ppv) #define PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND FAILURE #else /* PHP 7 */ /* MODULE */ #define PHPC_MODULE_GLOBALS_ACCESSOR ZEND_MODULE_GLOBALS_ACCESSOR #define PHPC_MODULE_HAS_THREAD_CACHE defined(ZTS) && defined(COMPILE_DL_JSON) /* INTEGER */ /* long type */ typedef zend_long phpc_long_t; /* unsigned long type */ typedef zend_ulong phpc_ulong_t; /* offset type */ typedef zend_off_t phpc_off_t; /* string length type */ typedef size_t phpc_str_size_t; #define PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc_over, _exc_under) \ PHPC_CONVERT_NUMBER(_plv, _lv, _exc_over, _exc_under, phpc_long_t, long, LONG_MAX, LONG_MIN) #define PHPC_LONG_TO_LONG_EX(_plv, _lv, _exc) \ PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc, _exc) #define PHPC_LONG_TO_LONG(_plv, _lv) \ PHPC_LONG_TO_LONG_EX2(_plv, _lv, _lv = LONG_MAX, _lv = LONG_MIN) #define PHPC_SIZE_TO_LONG_EX(_plv, _lv, _exc_over) \ PHPC_CONVERT_NUMBER_SIGNED(_plv, _lv, _exc_over, size_t, long, LONG_MAX) #define PHPC_SIZE_TO_LONG(_plv, _lv) \ PHPC_SIZE_TO_LONG_EX(_plv, _lv, _lv = LONG_MAX) #define PHPC_SIZE_TO_INT_EX(_plv, _lv, _exc_over) \ PHPC_CONVERT_NUMBER_SIGNED(_plv, _lv, _exc_over, size_t, int, INT_MAX) #define PHPC_SIZE_TO_INT(_plv, _lv) \ PHPC_SIZE_TO_LONG_EX(_plv, _lv, _lv = INT_MAX) /* STRING */ /* accessor and convertor macros */ #define PHPC_STR_VAL ZSTR_VAL #define PHPC_STR_LEN ZSTR_LEN #define PHPC_STR_LEN_FMT "zu" #define PHPC_STR_LEN_UNUSED(_name) PHPC_NOOP #define PHPC_STR_LEN_FROM_VAL PHPC_STR_LEN #define PHPC_STR_LEN_DECLARE(_name) PHPC_NOOP #define PHPC_STR_LEN_FETCH(_name) PHPC_NOOP #define PHPC_STR_LEN_DECLARE_AND_FETCH(_name) PHPC_NOOP #define PHPC_STR_EXISTS(_name) (_name) #define PHPC_STR_DECLARE(_name) zend_string *_name #define PHPC_STR_ARG(_name) zend_string *_name #define PHPC_STR_ARG_VAL PHPC_STR_ARG #define PHPC_STR_ARG_PTR(_name) zend_string **_name #define PHPC_STR_ARG_PTR_VAL PHPC_STR_ARG_PTR #define PHPC_STR_PASS(_name) _name #define PHPC_STR_PASS_VAL PHPC_STR_PASS #define PHPC_STR_PASS_PTR(_name) &_name #define PHPC_STR_PASS_PTR_VAL PHPC_STR_PASS_PTR #define PHPC_STR_DEREF_VAL(_name) *_name #define PHPC_STR_FROM_PTR_STR(_str, _strp) _str = *_strp #define PHPC_STR_FROM_PTR_VAL(_str, _strpv) _str = *_strpv #define PHPC_STR_RETURN RETURN_STR #define PHPC_STR_FROM_ZVAL(_str, _zv) _str = Z_STR(_zv) #define PHPC_STR_FROM_PZVAL(_str, _pzv) _str = Z_STR_P(_pzv) /* wrapper macros */ #define PHPC_STR_INIT(_name, _cstr, _len) \ _name = zend_string_init(_cstr, _len, 0) #define PHPC_STR_ALLOC(_name, _len) \ _name = zend_string_alloc(_len, 0) #define PHPC_STR_REALLOC(_name, _len) \ _name = zend_string_realloc(_name, _len, 0) #define PHPC_STR_RELEASE(_name) \ zend_string_release(_name) /* C string */ #define PHPC_CSTRL_RETURN RETURN_STRINGL #define PHPC_CSTR_RETURN RETURN_STRING #define PHPC_CSTRL_RETVAL RETVAL_STRINGL #define PHPC_CSTR_RETVAL RETVAL_STRING /* ZSTR */ #define PHPC_ZSTR_VAL ZSTR_VAL /* Smart string */ #ifdef PHPC_SMART_STR_INCLUDE #include "zend_smart_str.h" #endif /* PHPC_SMART_STR_INCLUDE */ #ifdef PHPC_SMART_CSTR_INCLUDE #include "ext/standard/php_smart_string.h" /* smart_str for C string has been renamed in PHP 7 so we have to wrap it */ #define phpc_smart_cstr smart_string #define phpc_smart_cstr_alloc smart_string_alloc #define phpc_smart_cstr_free smart_string_free #define phpc_smart_cstr_append smart_string_append #define phpc_smart_cstr_appends smart_string_appends #define phpc_smart_cstr_appendl smart_string_appendl #define phpc_smart_cstr_appendc smart_string_appendc #define phpc_smart_cstr_append_long smart_string_append_long #define phpc_smart_cstr_append_unsigned smart_string_append_unsigned #define phpc_smart_cstr_0 smart_string_0 #endif /* PHPC_SMART_CSTR_INCLUDE */ /* RESOURCE */ typedef zend_resource phpc_res_entry_t; typedef zend_resource * phpc_res_value_t; #define PHPC_RES_REGISTER zend_register_resource #define PHPC_RES_FETCH(_pz_res, _res_type_name, _res_type) \ zend_fetch_resource(Z_RES_P(_pz_res), _res_type_name, _res_type) #define PHPC_RES_FETCH2(_pz_res, _res_type_name, _res_type_1, _res_type_2) \ zend_fetch_resource2(Z_RES_P(_pz_res), _res_type_name, _res_type_1, _res_type_2) #define PHPC_RES_DELETE(_pz_res) \ zend_list_delete(Z_RES_P(_pz_res)) #define PHPC_RES_CLOSE(_pz_res) \ zend_list_close(Z_RES_P(_pz_res)) /* resource to zval */ #define PHPC_RES_PZVAL(_res, _pzv) \ ZVAL_RES(_pzv, _res) #define PHPC_RES_RETVAL RETVAL_RES #define PHPC_RES_RETURN RETURN_RES /* OBJECT */ #define PHPC_CLASS_REGISTER_EX(_orig_class_entry, _parent_ce, _parent_name) \ zend_register_internal_class_ex(&_orig_class_entry, _parent_ce) #define PHPC_CLASS_REGISTER(_orig_class_entry) \ zend_register_internal_class(&_orig_class_entry) /* struct spec */ #define PHPC_OBJ_STRUCT_MEMBER_FIRST #define PHPC_OBJ_STRUCT_MEMBER_LAST zend_object std; #define PHPC_OBJ_STRUCT_BEGIN(_name) \ PHPC_OBJ_STRUCT_NAME(_name) { PHPC_OBJ_STRUCT_MEMBER_FIRST #define PHPC_OBJ_STRUCT_END() \ PHPC_OBJ_STRUCT_MEMBER_LAST }; #define PHPC_OBJ_FROM_ZOBJ(_name, _object) \ (PHPC_OBJ_STRUCT_NAME(_name) *)((char*)(_object) - XtOffsetOf(PHPC_OBJ_STRUCT_NAME(_name), std)) #define PHPC_OBJ_FROM_ZVAL(_name, _zv) \ PHPC_OBJ_FROM_ZOBJ(_name, Z_OBJ_P(_zv)) #if PHP_MAJOR_VERSION < 8 #define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZVAL #else #define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZOBJ #endif /* create_ex object handler helper */ #define PHPC_OBJ_HANDLER_CREATE_EX(_name) \ PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(zend_object *, _name, create_ex) \ (zend_class_entry *PHPC_CLASS_TYPE, int _phpc_init_props) #define PHPC_OBJ_HANDLER_CREATE_EX_IS_NEW() _phpc_init_props #define PHPC_OBJ_HANDLER_CREATE_EX_DECLARE() PHPC_NOOP #define PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name) \ ecalloc(1, sizeof(PHPC_OBJ_STRUCT_NAME(_name)) + sizeof(zval) * (PHPC_CLASS_TYPE->default_properties_count - 1)); #define PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(_intern) \ do { \ zend_object_std_init(&_intern->std, PHPC_CLASS_TYPE); \ if (_phpc_init_props) { \ PHPC_OBJ_PROPERTIES_INIT(&_intern->std, PHPC_CLASS_TYPE); \ } \ } while(0) #define PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, _intern) \ do { \ _intern->std.handlers = &PHPC_OBJ_GET_HANDLER_VAR_NAME(_name); \ return &_intern->std; \ } while(0) /* create object handler */ #define PHPC_OBJ_HANDLER_CREATE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object *, _name, create) \ (zend_class_entry *PHPC_CLASS_TYPE) #define PHPC_OBJ_HANDLER_CREATE_RETURN(_name) \ return PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(PHPC_CLASS_TYPE, 1) /* clone object handler */ #define PHPC_OBJ_HANDLER_CLONE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object *, _name, clone)(phpc_obj_t *PHPC_SELF) #define PHPC_OBJ_HANDLER_CLONE_DECLARE() PHPC_NOOP #define PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, _new_obj, _old_obj) \ do { \ _new_obj = PHPC_OBJ_FROM_ZOBJ(_name, PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(_old_obj->std.ce, 0)); \ zend_objects_clone_members(&_new_obj->std, &_old_obj->std); \ } while(0) #define PHPC_OBJ_HANDLER_CLONE_RETURN_EX(_new_obj) return &_new_obj->std; /* free object handler */ #define PHPC_OBJ_HANDLER_FREE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(void, _name, free)(zend_object *_phpc_object) #define PHPC_OBJ_HANDLER_FREE_DTOR(_intern) \ zend_object_std_dtor(&(_intern)->std) /* compare object handler */ #define PHPC_OBJ_HANDLER_COMPARE(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(int, _name, compare)(zval *_phpc_obj1, zval *_phpc_obj2) #define PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, _id, _obj) \ PHPC_OBJ_STRUCT_DECLARE(_name, _obj) = PHPC_OBJ_FROM_ZVAL(_name, _phpc_obj ## _id) /* handler setters */ #define PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(_handlers, _name) \ (_handlers).offset = XtOffsetOf(PHPC_OBJ_STRUCT_NAME(_name), std) #define PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(_handlers, _name) \ (_handlers).free_obj = PHPC_OBJ_GET_HANDLER_FCE(_name, free) /* read propery */ #define PHPC_READ_PROPERTY_RV_NAME _phpc_read_property_rv #define PHPC_READ_PROPERTY_RV_DECLARE zval PHPC_READ_PROPERTY_RV_NAME #define PHPC_READ_PROPERTY(_scope, _object, _name, _name_len, _silent) \ zend_read_property(_scope, PHPC_OBJ_FOR_PROP(_object), _name, _name_len, _silent, &PHPC_READ_PROPERTY_RV_NAME) /* HASH */ /* recursion protection */ #if PHP_VERSION_ID < 70299 #define PHPC_HASH_HAS_APPLY_COUNT(_tht) (ZEND_HASH_GET_APPLY_COUNT(_tht) > 0) #define PHPC_HASH_GET_APPLY_COUNT ZEND_HASH_GET_APPLY_COUNT #define PHPC_HASH_INC_APPLY_COUNT ZEND_HASH_INC_APPLY_COUNT #define PHPC_HASH_DEC_APPLY_COUNT ZEND_HASH_DEC_APPLY_COUNT #define PHPC_HASH_APPLY_PROTECTION ZEND_HASH_APPLY_PROTECTION #else #define PHPC_HASH_HAS_APPLY_COUNT GC_IS_RECURSIVE #define PHPC_HASH_GET_APPLY_COUNT GC_IS_RECURSIVE #define PHPC_HASH_INC_APPLY_COUNT GC_PROTECT_RECURSION #define PHPC_HASH_DEC_APPLY_COUNT GC_UNPROTECT_RECURSION #define PHPC_HASH_APPLY_PROTECTION(_tht) (!(GC_FLAGS(_tht) & GC_IMMUTABLE)) #endif /* add ptr */ #define PHPC_HASH_INDEX_ADD_PTR(_ht, _idx, _ptr, _ptr_size) \ zend_hash_index_add_ptr(_ht, _idx, _ptr) #define PHPC_HASH_STR_ADD_PTR(_ht, _str, _ptr, _ptr_size) \ zend_hash_add_ptr(_ht, _str, _ptr) #define PHPC_HASH_CSTRL_ADD_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ zend_hash_str_add_ptr(_ht, _cstr_value, _cstr_len, _ptr) #define PHPC_HASH_CSTR_ADD_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ zend_hash_str_add_ptr(_ht, _cstr_value, strlen(_cstr_value), _ptr) /* add */ #define PHPC_HASH_INDEX_ADD zend_hash_index_add #define PHPC_HASH_STR_ADD zend_hash_add #define PHPC_HASH_CSTRL_ADD zend_hash_str_add #define PHPC_HASH_CSTR_ADD(_ht, _cstr_value, _pzv) \ zend_hash_str_add(_ht, _cstr_value, strlen(_cstr_value), _pzv) /* next insert */ #define PHPC_HASH_NEXT_INDEX_INSERT_PTR(_ht, _ptr, _ptr_size) \ zend_hash_next_index_insert_ptr(_ht, _ptr) #define PHPC_HASH_NEXT_INDEX_INSERT zend_hash_next_index_insert /* update ptr */ #define PHPC_HASH_INDEX_UPDATE_PTR(_ht, _idx, _ptr, _ptr_size) \ zend_hash_index_update_ptr(_ht, _idx, _ptr) #define PHPC_HASH_STR_UPDATE_PTR(_ht, _str, _ptr, _ptr_size) \ zend_hash_update_ptr(_ht, _str, _ptr) #define PHPC_HASH_CSTRL_UPDATE_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ zend_hash_str_update_ptr(_ht, _cstr_value, _cstr_len, _ptr) #define PHPC_HASH_CSTR_UPDATE_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ zend_hash_str_update_ptr(_ht, _cstr_value, strlen(_cstr_value), _ptr) /* update */ #define PHPC_HASH_INDEX_UPDATE zend_hash_index_update #define PHPC_HASH_STR_UPDATE zend_hash_update #define PHPC_HASH_CSTRL_UPDATE zend_hash_str_update #define PHPC_HASH_CSTR_UPDATE(_ht, _cstr_value, _pzv) \ zend_hash_str_update(_ht, _cstr_value, strlen(_cstr_value), _pzv) /* delete */ #define PHPC_HASH_INDEX_DELETE zend_hash_index_del #define PHPC_HASH_STR_DELETE zend_hash_del #define PHPC_HASH_CSTRL_DELETE zend_hash_str_del #define PHPC_HASH_CSTR_DELETE(_ht, _cstr_value) \ zend_hash_str_del(_ht, _cstr_value, strlen(_cstr_value)) /* exists */ #define PHPC_HASH_INDEX_EXISTS zend_hash_index_exists #define PHPC_HASH_STR_EXISTS zend_hash_exists #define PHPC_HASH_CSTRL_EXISTS zend_hash_str_exists #define PHPC_HASH_CSTR_EXISTS(_ht, _cstr_value) \ zend_hash_str_exists(_ht, _cstr_value, strlen(_cstr_value)) /* find */ #define PHPC_HASH_STR_FIND(_ht, _str, _ppv) \ _ppv = zend_hash_find(_ht, _str) #define PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv) \ _ppv = zend_hash_str_find(_ht, _cstr_value, _cstr_len) #define PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv) \ _ppv = zend_hash_str_find(_ht, _cstr_value, strlen(_cstr_value)) #define PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv) \ _ppv = zend_hash_index_find(_ht, _idx) /* find ptr */ #define PHPC_HASH_STR_FIND_PTR(_ht, _str, _ptr) \ _ptr = zend_hash_find_ptr(_ht, _str) #define PHPC_HASH_CSTRL_FIND_PTR(_ht, _cstr_value, _cstr_len, _ptr) \ _ptr = zend_hash_str_find_ptr(_ht, _cstr_value, _cstr_len) #define PHPC_HASH_CSTR_FIND_PTR(_ht, _cstr_value, _ptr) \ _ptr = zend_hash_str_find_ptr(_ht, _cstr_value, strlen(_cstr_value)) #define PHPC_HASH_INDEX_FIND_PTR(_ht, _idx, _ptr) \ _ptr = zend_hash_index_find_ptr(_ht, _idx) /* not found value */ #define PHPC_HASH_NOT_FOUND NULL /* iteration for each element */ #define PHPC_HASH_FOREACH_KEY ZEND_HASH_FOREACH_KEY #define PHPC_HASH_FOREACH_VAL ZEND_HASH_FOREACH_VAL #define PHPC_HASH_FOREACH_VAL_IND ZEND_HASH_FOREACH_VAL_IND #define PHPC_HASH_FOREACH_KEY_VAL ZEND_HASH_FOREACH_KEY_VAL #define PHPC_HASH_FOREACH_KEY_VAL_IND ZEND_HASH_FOREACH_KEY_VAL_IND #define PHPC_HASH_FOREACH_STR_KEY_VAL ZEND_HASH_FOREACH_STR_KEY_VAL #define PHPC_HASH_FOREACH_STR_KEY_VAL_IND ZEND_HASH_FOREACH_STR_KEY_VAL_IND #define PHPC_HASH_FOREACH_END ZEND_HASH_FOREACH_END /* key and data getter */ #define PHPC_HASH_GET_CURRENT_KEY_EX(_ht, _str, _num_index, _pos) \ zend_hash_get_current_key_ex(_ht, &_str, &_num_index, _pos) #define PHPC_HASH_GET_CURRENT_DATA_EX(_ht, _val, _pos) \ _val = zend_hash_get_current_data_ex(_ht, _pos) #define PHPC_HASH_GET_CURRENT_KEY(_ht, _str, _num_index) \ zend_hash_get_current_key(_ht, &_str, &_num_index) #define PHPC_HASH_GET_CURRENT_DATA(_ht, _val) \ _val = zend_hash_get_current_data(_ht) /* copy */ #define PHPC_HASH_COPY_EX(_target, _source, _copy_ctr) \ zend_hash_copy(_target, _source, NULL) /* hash to zval */ #define PHPC_HASH_PZVAL(_ht, _pzv) \ ZVAL_ARR(_pzv, _ht) #define PHPC_HASH_RETVAL RETVAL_ARR #define PHPC_HASH_RETURN RETURN_ARR /* SYMTABLE */ /* update*/ #define PHPC_SYMTABLE_UPDATE zend_symtable_update /* ARRAY */ #define PHPC_ARRAY_ADD_ASSOC_NULL_EX add_assoc_null_ex #define PHPC_ARRAY_ADD_ASSOC_BOOL_EX add_assoc_bool_ex #define PHPC_ARRAY_ADD_ASSOC_LONG_EX add_assoc_long_ex #define PHPC_ARRAY_ADD_ASSOC_RESOURCE_EX add_assoc_resource_ex #define PHPC_ARRAY_ADD_ASSOC_DOUBLE_EX add_assoc_double_ex #define PHPC_ARRAY_ADD_ASSOC_STR_EX add_assoc_str_ex #define PHPC_ARRAY_ADD_ASSOC_CSTR_EX add_assoc_string_ex #define PHPC_ARRAY_ADD_ASSOC_CSTRL_EX add_assoc_stringl_ex #define PHPC_ARRAY_ADD_ASSOC_ZVAL_EX add_assoc_zval_ex #define PHPC_ARRAY_ADD_ASSOC_VAL_EX(_arr, _key, _key_len, _pv) \ add_assoc_zval_ex(_arr, _key, _key_len, &_pv) #define PHPC_ARRAY_ADD_ASSOC_STR add_assoc_str #define PHPC_ARRAY_ADD_ASSOC_CSTR add_assoc_string #define PHPC_ARRAY_ADD_ASSOC_CSTRL add_assoc_stringl #define PHPC_ARRAY_ADD_ASSOC_VAL(_arr, _key, _pv) \ add_assoc_zval(_arr, _key, &_pv) #define PHPC_ARRAY_ADD_INDEX_STR add_index_str #define PHPC_ARRAY_ADD_INDEX_CSTR add_index_string #define PHPC_ARRAY_ADD_INDEX_CSTRL add_index_stringl #define PHPC_ARRAY_ADD_INDEX_VAL(_arr, _idx, _pv) \ add_index_zval(_arr, _idx, &_pv) #define PHPC_ARRAY_ADD_NEXT_INDEX_STR add_next_index_str #define PHPC_ARRAY_ADD_NEXT_INDEX_CSTR add_next_index_string #define PHPC_ARRAY_ADD_NEXT_INDEX_CSTRL add_next_index_stringl #define PHPC_ARRAY_ADD_NEXT_INDEX_VAL(_arr, _pv) \ add_next_index_zval(_arr, &_pv) /* FCALL */ #define PHPC_FCALL_PARAMS_DECLARE(_pname, _count) \ zval PHPC_FCALL_PARAMS_NAME(_pname)[_count] #define PHPC_FCALL_PARAMS_INIT(_pname) PHPC_NOOP #define PHPC_FCALL_PARAM_PZVAL(_pname, _idx) \ &PHPC_FCALL_PARAMS_NAME(_pname)[_idx] #define PHPC_FCALL_PARAM_VAL(_pname, _idx) \ PHPC_FCALL_PARAMS_NAME(_pname)[_idx] #define PHPC_FCALL_PARAM_UNDEF(_pname, _idx) \ ZVAL_UNDEF(PHPC_FCALL_PARAM_PZVAL(_pname, _idx)) #define PHPC_FCALL_RETVAL(_fci, _pv) \ (_fci).retval = (&_pv) /* ZVAL */ typedef zval phpc_val; #define PHPC_TYPE Z_TYPE #define PHPC_TYPE_P Z_TYPE_P #define PHPC_LVAL Z_LVAL #define PHPC_LVAL_P Z_LVAL_P #define PHPC_DVAL Z_DVAL #define PHPC_DVAL_P Z_DVAL_P #define PHPC_STRVAL Z_STRVAL #define PHPC_STRVAL_P Z_STRVAL_P #define PHPC_STRLEN Z_STRLEN #define PHPC_STRLEN_P Z_STRLEN_P #define PHPC_ARRVAL Z_ARRVAL #define PHPC_ARRVAL_P Z_ARRVAL_P #define PHPC_OBJ_HT Z_OBJ_HT #define PHPC_OBJ_HT_P Z_OBJ_HT_P #define PHPC_OBJ_HANDLER Z_OBJ_HANDLER #define PHPC_OBJ_HANDLER_P Z_OBJ_HANDLER_P #define PHPC_OBJ_HANDLE Z_OBJ_HANDLE #define PHPC_OBJ_HANDLE_P Z_OBJ_HANDLE_P #define PHPC_OBJCE Z_OBJCE #define PHPC_OBJCE_P Z_OBJCE_P #define PHPC_OBJPROP Z_OBJPROP #define PHPC_OBJPROP_P Z_OBJPROP_P #define PHPC_OBJDEBUG Z_OBJDEBUG #define PHPC_OBJDEBUG_P Z_OBJDEBUG_P #define PHPC_REFCOUNTED Z_REFCOUNTED #define PHPC_REFCOUNTED_P Z_REFCOUNTED_P #define PHPC_PZVAL_CAST_TO_PVAL(_pzv) _pzv #define PHPC_VAL_CAST_TO_ZVAL(_pv) _pv #define PHPC_VAL_CAST_TO_PZVAL(_pv) &(_pv) #define PHPC_PVAL_CAST_TO_PZVAL(_ppv) _ppv #define PHPC_VAL_TO_ZVAL(_pv, _zv) _zv = _pv #define PHPC_VAL_TO_PZVAL(_pv, _zv) _zv = &(_pv) #define PHPC_PVAL_TO_PZVAL(_ppv, _zv) _zv = _ppv #define PHPC_VAL_MAKE(_pv) PHPC_NOOP #define PHPC_VAL_FREE(_pv) PHPC_NOOP #define PHPC_VAL_UNDEF(_pv) ZVAL_UNDEF(&(_pv)) #define PHPC_VAL_ISUNDEF(_pv) Z_ISUNDEF(_pv) #define PHPC_VAL_COPY(_pv, _zv) ZVAL_COPY(&(_pv), _zv) #define PHPC_VAL_ASSIGN PHPC_VAL_COPY #define PHPC_PZVAL_MAKE(_pzv) PHPC_NOOP #define PHPC_PZVAL_FREE(_pzv) PHPC_NOOP #define PHPC_PZVAL_SET(_pv, _zv) _pv = _zv #define PHPC_PVAL_DEREF ZVAL_DEREF #define PHPC_PZVAL_DEREF ZVAL_DEREF #define PHPC_PZVAL_COPY_INIT ZVAL_COPY_VALUE #define PHPC_PZVAL_COPY ZVAL_COPY_VALUE #define PHPC_VAL_NEW_STR(_pv, _str) \ ZVAL_NEW_STR(&_pv, _str) #define PHPC_VAL_STR(_pv, _str) \ ZVAL_STR(&_pv, _str) #define PHPC_VAL_CSTR(_pv, _cstr) \ ZVAL_STRING(&_pv, _cstr) #define PHPC_VAL_CSTRL(_pv, _cstr, _cstr_len) \ ZVAL_STRINGL(&_pv, _cstr, _cstr_len) #define PHPC_PZVAL_NEW_STR ZVAL_NEW_STR #define PHPC_PZVAL_STR ZVAL_STR #define PHPC_PZVAL_CSTR ZVAL_STRING #define PHPC_PZVAL_CSTRL ZVAL_STRINGL #define PHPC_ZVAL_COPY(_zv_dst, _zv_src) \ ZVAL_COPY_VALUE(&_zv_dst, &_zv_src) #define PHPC_ZVAL_NEW_STR PHPC_VAL_NEW_STR #define PHPC_ZVAL_STR PHPC_VAL_STR #define PHPC_ZVAL_CSTR PHPC_VAL_CSTR #define PHPC_ZVAL_CSTRL PHPC_VAL_CSTRL #define PHPC_ZVAL_IS_TRUE(_zv) \ (Z_TYPE(_zv) == IS_TRUE) #define PHPC_ZVAL_IS_FALSE(_zv) \ (Z_TYPE(_zv) == IS_FALSE) #define PHPC_VAL_IS_TRUE PHPC_ZVAL_IS_TRUE #define PHPC_VAL_IS_FALSE PHPC_ZVAL_IS_FALSE #define PHPC_FE_END PHP_FE_END /* ZPP */ /* path flag */ #define PHPC_ZPP_PATH_FLAG "p" /* args */ #define PHPC_ZPP_ARGS_DECLARE() \ int _phpc_zpp_args_count = 0; \ zval *_phpc_zpp_args_array #define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ do { \ if (zend_parse_parameters(_num_args, #_flag, \ &_phpc_zpp_args_array, &_phpc_zpp_args_count) == FAILURE) { \ _return; \ } \ } while(0) #define PHPC_ZPP_ARGS_GET_PVAL(_arg_pos) \ &_phpc_zpp_args_array[_arg_pos] #define PHPC_ZPP_ARGS_FREE() PHPC_NOOP /* STREAM */ typedef const char phpc_stream_opener_char_t; #define PHPC_STREAM_WRAPPERDATA_ALLOC(stream) PHPC_NOOP #define PHPC_STREAM_WRAPPERDATA_ISSET(stream) (Z_TYPE(stream->wrapperdata) != IS_UNDEF) #define PHPC_STREAM_WRAPPERDATA_UNSET(stream) \ do { \ zval_ptr_dtor(&stream->wrapperdata); \ ZVAL_UNDEF(&stream->wrapperdata); \ } while(0) #define PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv) \ _ppv = php_stream_context_get_option(_ctx, _wrappername, _optionname) #define PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND NULL #endif /* PHP_MAJOR_VERSION */ /* COMMON (dependent definitions) */ /* object structure */ #define PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) \ PHPC_OBJ_FROM_ZOBJ(_name, _phpc_object) #define PHPC_OBJ_STRUCT_DECLARE_AND_FETCH_FROM_ZOBJ(_name, _ptr) \ PHPC_OBJ_STRUCT_DECLARE(_name, _ptr) = PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) #define PHPC_OBJ_FROM_SELF(_name) \ PHPC_OBJ_FROM_POBJ(_name, PHPC_SELF) /* this object */ #define PHPC_THIS _phpc_this #define PHPC_THIS_DECLARE(_name) PHPC_OBJ_STRUCT_DECLARE(_name, PHPC_THIS) #define PHPC_THIS_FETCH_FROM_ZVAL(_name, _zv) \ PHPC_THIS = PHPC_OBJ_FROM_ZVAL(_name, _zv) #define PHPC_THIS_FETCH(_name) \ PHPC_THIS_FETCH_FROM_ZVAL(_name, getThis()) #define PHPC_THIS_DECLARE_AND_FETCH_FROM_ZVAL(_name, _zv) \ PHPC_THIS_DECLARE(_name) = PHPC_THIS_FETCH_FROM_ZVAL(_name, _zv) #define PHPC_THIS_FETCH_FROM_SELF(_name) \ PHPC_THIS = PHPC_OBJ_FROM_SELF(_name) #define PHPC_THIS_DECLARE_AND_FETCH_FROM_SELF(_name) \ PHPC_THIS_DECLARE(_name) = PHPC_OBJ_FROM_SELF(_name) #define PHPC_THIS_DECLARE_AND_FETCH(_name) \ PHPC_THIS_DECLARE_AND_FETCH_FROM_ZVAL(_name, getThis()) /* that object */ #define PHPC_THAT _phpc_that #define PHPC_THAT_DECLARE(_name) PHPC_OBJ_STRUCT_DECLARE(_name, PHPC_THAT) /* object helper create_ex */ #define PHPC_OBJ_HANDLER_CREATE_EX_INIT(_name) \ PHPC_OBJ_HANDLER_CREATE_EX_DECLARE(); \ PHPC_THIS_DECLARE(_name); \ PHPC_THIS = PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name); \ PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(PHPC_THIS) #define PHPC_OBJ_HANDLER_CREATE_EX_RETURN(_name) \ PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, PHPC_THIS) /* object handler clone */ #define PHPC_OBJ_HANDLER_CLONE_INIT(_name) \ PHPC_OBJ_HANDLER_CLONE_DECLARE(); \ PHPC_THIS_DECLARE(_name); \ PHPC_THAT_DECLARE(_name); \ PHPC_THIS = PHPC_OBJ_FROM_SELF(_name); \ PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, PHPC_THAT, PHPC_THIS) #define PHPC_OBJ_HANDLER_CLONE_RETURN() \ PHPC_OBJ_HANDLER_CLONE_RETURN_EX(PHPC_THAT) /* object handler free */ #define PHPC_OBJ_HANDLER_FREE_INIT(_name) \ PHPC_OBJ_STRUCT_DECLARE_AND_FETCH_FROM_ZOBJ(_name, PHPC_THIS); #define PHPC_OBJ_HANDLER_FREE_DESTROY() \ PHPC_OBJ_HANDLER_FREE_DTOR(PHPC_THIS) /* object handler compare */ #define PHPC_OBJ_HANDLER_COMPARE_INIT(_name) \ PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, 1, PHPC_THIS); \ PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, 2, PHPC_THAT) /* object handler get_gc */ #define PHPC_GC_TABLE _phpc_gc_table #define PHPC_GC_N _phpc_gc_n #define PHPC_OBJ_HANDLER_GET_GC(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_gc)\ (phpc_obj_t *PHPC_SELF, phpc_val **PHPC_GC_TABLE, int *PHPC_GC_N TSRMLS_DC) /* object handler get_debug_info */ #define PHPC_DEBUG_INFO_IS_TEMP _phpc_debug_info_is_temp #define PHPC_OBJ_HANDLER_GET_DEBUG_INFO(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_debug_info)\ (phpc_obj_t *PHPC_SELF, int *PHPC_DEBUG_INFO_IS_TEMP TSRMLS_DC) /* object handler get_properties */ #define PHPC_OBJ_HANDLER_GET_PROPERTIES(_name) \ PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_properties)\ (phpc_obj_t *PHPC_SELF TSRMLS_DC) /* object handler setters */ #define PHPC_CLASS_SET_HANDLER_CREATE(_class_entry, _name) \ _class_entry.create_object = PHPC_OBJ_GET_HANDLER_FCE(_name, create) #define PHPC_OBJ_SET_SPECIFIC_HANDLER_CLONE(_handlers, _name) \ (_handlers).clone_obj = PHPC_OBJ_GET_HANDLER_FCE(_name, clone) #define PHPC_OBJ_SET_HANDLER_CLONE(_name) \ PHPC_OBJ_SET_SPECIFIC_HANDLER_CLONE(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) #define PHPC_OBJ_SET_HANDLER_COMPARE(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).PHPC_OBJ_HANDLER_COMPARE_NAME \ = PHPC_OBJ_GET_HANDLER_FCE(_name, compare) #define PHPC_OBJ_HAS_HANDLER_GET_GC (PHP_VERSION_ID > 50399) #if PHPC_OBJ_HAS_HANDLER_GET_GC #define PHPC_OBJ_SET_HANDLER_GET_GC(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_gc = PHPC_OBJ_GET_HANDLER_FCE(_name, get_gc) #else #define PHPC_OBJ_SET_HANDLER_GET_GC(_name) PHPC_NOOP #endif #define PHPC_OBJ_HAS_HANDLER_GET_DEBUG_INFO (PHP_VERSION_ID > 50299) #if PHPC_OBJ_HAS_HANDLER_GET_DEBUG_INFO #define PHPC_OBJ_SET_HANDLER_GET_DEBUG_INFO(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_debug_info = PHPC_OBJ_GET_HANDLER_FCE(_name, get_debug_info) #else #define PHPC_OBJ_SET_HANDLER_GET_DEBUG_INFO(_name) PHPC_NOOP #endif /* there is such handler in 5.2 but we would have to re-implement zend_std_get_properties */ #define PHPC_OBJ_HAS_HANDLER_GET_PROPERTIES (PHP_VERSION_ID > 50299) #if PHPC_OBJ_HAS_HANDLER_GET_PROPERTIES #define PHPC_OBJ_SET_HANDLER_GET_PROPERTIES(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_properties = PHPC_OBJ_GET_HANDLER_FCE(_name, get_properties) #else #define PHPC_OBJ_SET_HANDLER_GET_PROPERTIES(_name) PHPC_NOOP #endif #define PHPC_OBJ_SET_HANDLER_OFFSET(_name) \ PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) #define PHPC_OBJ_SET_HANDLER_FREE(_name) \ PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) /* hash */ #define PHPC_HASH_ALLOC ALLOC_HASHTABLE #define PHPC_HASH_INIT zend_hash_init #define PHPC_HASH_NUM_ELEMENTS zend_hash_num_elements #define PHPC_HASH_HAS_MORE_ELEMENTS_EX zend_hash_has_more_elements_ex #define PHPC_HASH_MOVE_FORWARD_EX zend_hash_move_forward_ex #define PHPC_HASH_MOVE_BACKWARDS_EX zend_hash_move_backwards_ex #define PHPC_HASH_GET_CURRENT_KEY_ZVAL_EX zend_hash_get_current_key_zval_ex #define PHPC_HASH_GET_CURRENT_KEY_TYPE_EX zend_hash_get_current_key_type_ex #define PHPC_HASH_INTERNAL_POINTER_RESET_EX zend_hash_internal_pointer_reset_ex #define PHPC_HASH_INTERNAL_POINTER_END_EX zend_hash_internal_pointer_end_ex #define PHPC_HASH_HAS_MORE_ELEMENTS zend_hash_has_more_elements #define PHPC_HASH_MOVE_FORWARD zend_hash_move_forward #define PHPC_HASH_MOVE_BACKWARDS zend_hash_move_backwards #define PHPC_HASH_GET_CURRENT_KEY_ZVAL zend_hash_get_current_key_zval #define PHPC_HASH_GET_CURRENT_KEY_TYPE zend_hash_get_current_key_type #define PHPC_HASH_INTERNAL_POINTER_RESET zend_hash_internal_pointer_reset #define PHPC_HASH_INTERNAL_POINTER_END zend_hash_internal_pointer_end /* find */ #define PHPC_HASH_IS_FOUND(_found) ((_found) != PHPC_HASH_NOT_FOUND) /* find in cond */ #define PHPC_HASH_STR_FIND_IN_COND(_ht, _str, _ppv) \ PHPC_HASH_IS_FOUND(PHPC_HASH_STR_FIND(_ht, _str, _ppv)) #define PHPC_HASH_CSTRL_FIND_IN_COND(_ht, _cstr_value, _cstr_len, _ppv) \ PHPC_HASH_IS_FOUND(PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv)) #define PHPC_HASH_CSTR_FIND_IN_COND(_ht, _cstr_value, _ppv) \ PHPC_HASH_IS_FOUND(PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv)) #define PHPC_HASH_INDEX_FIND_IN_COND(_ht, _idx, _ppv) \ PHPC_HASH_IS_FOUND(PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv)) /* find ptr in cond */ #define PHPC_HASH_STR_FIND_PTR_IN_COND(_ht, _str, _ptr) \ PHPC_HASH_IS_FOUND(PHPC_HASH_STR_FIND_PTR(_ht, _str, _ptr)) #define PHPC_HASH_CSTRL_FIND_PTR_IN_COND(_ht, _cstr_value, _cstr_len, _ptr) \ PHPC_HASH_IS_FOUND(PHPC_HASH_CSTRL_FIND_PTR(_ht, _cstr_value, _cstr_len, _ptr)) #define PHPC_HASH_CSTR_FIND_PTR_IN_COND(_ht, _cstr_value, _ptr) \ PHPC_HASH_IS_FOUND(PHPC_HASH_CSTR_FIND_PTR(_ht, _cstr_value, _ptr)) #define PHPC_HASH_INDEX_FIND_PTR_IN_COND(_ht, _idx, _ptr) \ PHPC_HASH_IS_FOUND(PHPC_HASH_INDEX_FIND_PTR(_ht, _idx, _ptr)) /* copy */ #define PHPC_HASH_COPY(_target, _source) \ PHPC_HASH_COPY_EX(_target, _source, NULL) /* array */ #define PHPC_ARRAY_INIT array_init #if PHP_VERSION_ID < 50299 #define PHPC_ARRAY_INIT_SIZE(_arr, _size) array_init(_arr) #else #define PHPC_ARRAY_INIT_SIZE array_init_size #endif #define PHPC_ARRAY_ADD_ASSOC_NULL add_assoc_null #define PHPC_ARRAY_ADD_ASSOC_BOOL add_assoc_bool #define PHPC_ARRAY_ADD_ASSOC_LONG add_assoc_long #define PHPC_ARRAY_ADD_ASSOC_RESOURCE add_assoc_resource #define PHPC_ARRAY_ADD_ASSOC_DOUBLE add_assoc_double #define PHPC_ARRAY_ADD_ASSOC_ZVAL add_assoc_zval #define PHPC_ARRAY_ADD_INDEX_NULL add_index_null #define PHPC_ARRAY_ADD_INDEX_BOOL add_index_bool #define PHPC_ARRAY_ADD_INDEX_LONG add_index_long #define PHPC_ARRAY_ADD_INDEX_RESOURCE add_index_resource #define PHPC_ARRAY_ADD_INDEX_DOUBLE add_index_double #define PHPC_ARRAY_ADD_INDEX_ZVAL add_index_zval #define PHPC_ARRAY_ADD_NEXT_INDEX_NULL add_next_index_null #define PHPC_ARRAY_ADD_NEXT_INDEX_BOOL add_next_index_bool #define PHPC_ARRAY_ADD_NEXT_INDEX_LONG add_next_index_long #define PHPC_ARRAY_ADD_NEXT_INDEX_RESOURCE add_next_index_resource #define PHPC_ARRAY_ADD_NEXT_INDEX_DOUBLE add_next_index_double #define PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL add_next_index_zval /* ZPP */ /* alias for path flag */ #define PHPC_PATH_ZPP_FLAG PHPC_ZPP_PATH_FLAG /* args loading */ #define PHPC_ZPP_ARGS_LOAD(_flag) PHPC_ZPP_ARGS_LOAD_EX(_flag, ZEND_NUM_ARGS(), return) #define PHPC_ZPP_ARGS_LOOP_START_EX(_start) \ do { \ int _phpc_zpp_args_i; \ for (_phpc_zpp_args_i = _start; _phpc_zpp_args_i < _phpc_zpp_args_count; _phpc_zpp_args_i++) #define PHPC_ZPP_ARGS_LOOP_START() PHPC_ZPP_ARGS_LOOP_START_EX(0) #define PHPC_ZPP_ARGS_LOOP_END() \ } while(0) #define PHPC_ZPP_ARGS_GET_CURRENT_PVAL() PHPC_ZPP_ARGS_GET_PVAL(_phpc_zpp_args_i) #define PHPC_ZPP_ARGS_COUNT _phpc_zpp_args_count /* FCALL */ #if PHP_API_VERSION < 20090626 #define PHPC_FCALL_INFO_INIT(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error) \ zend_fcall_info_init(_callable, &fci, &fci_cache TSRMLS_CC) #else #define PHPC_FCALL_INFO_INIT(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error) \ zend_fcall_info_init(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error TSRMLS_CC) #endif /* stream */ #define PHPC_STREAM_CONTEXT_GET_OPTION_IN_COND(_ctx, _wrappername, _optionname, _ppv) \ ((PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv)) != \ PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND) #if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 6) || (PHP_MAJOR_VERSION > 5) #define PHPC_STREAM_LOCATE_URL_WRAPPER(_path, _path_for_open, _options) \ php_stream_locate_url_wrapper(_path, (const char **) _path_for_open, _options TSRMLS_CC) #else #define PHPC_STREAM_LOCATE_URL_WRAPPER(_path, _path_for_open, _options) \ php_stream_locate_url_wrapper(_path, (char **) _path_for_open, _options TSRMLS_CC) #endif #if (PHP_MAJOR_VERSION == 8 && PHP_MINOR_VERSION >= 1) || (PHP_MAJOR_VERSION > 8) #define PHPC_PHP_STAT(_filename, _filename_length, _type, _return_value) do { \ zend_string *_phpc_stat_str = zend_string_init(_filename, _filename_length, 0); \ php_stat(_phpc_stat_str, _type, _return_value); \ zend_string_release(_phpc_stat_str); \ } while (0) #else #define PHPC_PHP_STAT php_stat #endif #endif /* PHPC_H */ gnupg-1.5.1/tests/gnupg_oo_deletekey.phpt0000664000175000017500000000057114163677356017546 0ustar jakubjakub--TEST-- delete a key from the keyring --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg->deletekey($fingerprint,true); var_dump($ret); ?> --EXPECT-- bool(true) --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_encrypt.phpt0000664000175000017500000000077514163677356017265 0ustar jakubjakub--TEST-- encrypt and decrypt a text --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->addencryptkey($fingerprint); $enc = $gpg->encrypt($plaintext); $gpg = new gnupg(); $gpg->adddecryptkey($fingerprint, $passphrase); $ret = $gpg->decrypt($enc); var_dump($ret); ?> --EXPECTF-- string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_encryptsign.phpt0000664000175000017500000000154114163677356020136 0ustar jakubjakub--TEST-- encryptsign and decryptverify a text --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->addencryptkey($fingerprint); $gpg->addsignkey($fingerprint, $passphrase); $enc = $gpg->encryptsign($plaintext); $plaintext = false; $gpg = new gnupg(); $gpg->adddecryptkey($fingerprint, $passphrase); $ret = $gpg->decryptverify ($enc, $plaintext); var_dump($ret); var_dump($plaintext); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_export.phpt0000664000175000017500000000375414163677356017122 0ustar jakubjakub--TEST-- export a key --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg->export($fingerprint); var_dump($ret); ?> --EXPECTF-- string(%d) "-----BEGIN PGP PUBLIC KEY BLOCK----- mQENBF11JawBCAC6bWTtKtAj1dBih/UHR9iH1iADEmZde52aKyd7EXKtjs4Q2aXJ kbn9R+kcJNx+AlnTSePQBkNz5brmEAQgk93rOsHaPUEROkfBR2C6AkjaJNnk0E43 pbUy6bWhmGR4kmpbvRnR/7kxVyplb5zSFAcio1I8RQ3ql0HkF//zLUouYzrMJn6e GvffHw1revlSxo0leCcOsNE7AHGVgMxvUWYO0JT4Fs+JcpsTxG8MFE6I6SLZoY5W XmtOsO0vMNJoTaXdqfJoLTkviPkRUZuF0DtzuT1oQLUTTaKvWxx2+33YF5HYrlNy eepLFLh5mZ1/2HFWoQo2X1gFfb1R9EJPbFtJABEBAAG0GVBIUCBHbnVQRyA8Z251 cGdAcGhwLm5ldD6JATgEEwECACIFAl11JawCGwMGCwkIBwMCBhUIAgkKCwQWAgMB Ah4BAheAAAoJEGaed14KYoSzo2QH/AxR9nAqevgbp2GHw+xw4R8XVHMeL2atROFU ndldeYmtVNGh8ck/YSxMz/FY2qLbN3421xOi/ct7nVl77MLZxgZAnsD5qnm0doJl Su/URzUmyhinKLmB9AdklGJNXrL0/dWF0t46Dmv+4W+Qnx3mNhZBUbSW5Ut2pXq0 d4XPTHfkQWgaTPblw97ncQzwVmDSLRqoJEl3yo3OW8/uE1a/ldivuMux5IEcA03l 5L/5g2QOe9cRxk+x9JCXBPqjJ9OIVMUUReGBVSfscGAhnD0bW/aNf5//eGkU9Gai CCSdnIKCopRJSIZcv3OF+P+vh3gmGXAByyQKRvwpBdvosIsiEXi5AQ0EXXUlrAEI AO43Q3D/VgdGGpHa4P0ppv6gY5jBnPHvpyd3Opu497H0z6Xe8rZfRxSpyOViPjF4 NIe2OX6tEAK/hYkH0o91BwbMGAwiljKomL45G4vPb0ve86d/MGrtdeDRt8WhlDEB VfKpxi1bFtq7KvHvnv51iATndM1wE2v79vssMdmJEPRipo+GHiPoThEoO2bdtwI1 thHpUsdXPGpeMcM3F9FmdYpdsFsoyzZ6if7cbijhO4OArGNUm3oJTu66Vok9GjSa V7HsLHJMNf/6Lc66FQSG8+kUKZ/R7s8NY+fS2oFONba3DT5qzA80rfiAFheeAFUz HE3NLkkdPsnzNBOOtRot3bUAEQEAAYkBHwQYAQIACQUCXXUlrAIbDAAKCRBmnnde CmKEs3t+B/4vUc2oXZXuEzIfL7Atv20VJomQCHrsbnNHErqCDJ+TpH6yjcKGGBNR zlOOUpZWFN1Ii2Wml+XIIzOXiOhhH/A6iTTAVl72RQWwiRjm8kYYWThT4msPd5yX QulbZRMxorIIrzs0tjIc5z5FXhSQhIaRjMSKqwJ/VGS9KEWut1F5akJNv/3klMW6 UTIxnj0IMlnL+GaPBf+f1+3Pxoli37aeISxzvLhtquLXc++ls9ICwF6CN9D+Vtp+ H2JaNPDtdHUzVBv0xQ1E3B1XeCiOIDFwWPWvCCY1FbgKXNrn5fdgsk69dLtTGJ4A WU7na8AWygvMcdtuGjpNE4g24ln7Rrce =sQ2w -----END PGP PUBLIC KEY BLOCK----- " --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_getengineinfo.phpt0000664000175000017500000000062514163677356020414 0ustar jakubjakub--TEST-- get engineinfo --SKIPIF-- --FILE-- getengineinfo(); var_dump($ret); ?> --EXPECTF-- array(3) { ["protocol"]=> int(0) ["file_name"]=> string(%d) %s ["home_dir"]=> string(0) "" } --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_geterror.phpt0000664000175000017500000000043614163677356017424 0ustar jakubjakub--TEST-- get error --SKIPIF-- --FILE-- geterror()); ?> --EXPECTF-- bool(false) --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_geterrorinfo.phpt0000664000175000017500000000071414163677356020277 0ustar jakubjakub--TEST-- get error info --SKIPIF-- --FILE-- geterrorinfo()); ?> --EXPECT-- array(4) { ["generic_message"]=> bool(false) ["gpgme_code"]=> int(0) ["gpgme_source"]=> string(18) "Unspecified source" ["gpgme_message"]=> string(7) "Success" } --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_import.phpt0000664000175000017500000000125014163677356017100 0ustar jakubjakub--TEST-- import a new key into the keyring --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg->import($testkey); var_dump($ret); ?> --EXPECT-- array(9) { ["imported"]=> int(1) ["unchanged"]=> int(0) ["newuserids"]=> int(0) ["newsubkeys"]=> int(0) ["secretimported"]=> int(1) ["secretunchanged"]=> int(0) ["newsignatures"]=> int(0) ["skippedkeys"]=> int(0) ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" } --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_init_file_name.phpt0000664000175000017500000000061514163677356020534 0ustar jakubjakub--TEST-- init object with custom file_name --SKIPIF-- --FILE-- '/usr/bin/gpg')); $engine = $gpg->getengineinfo(); var_dump($engine['file_name']); ?> --EXPECT-- string(12) "/usr/bin/gpg"gnupg-1.5.1/tests/gnupg_oo_init_home_dir.phpt0000664000175000017500000000122414163677356020400 0ustar jakubjakub--TEST-- init object with custom home_dir --SKIPIF-- --FILE-- $homedir)); $gpg->seterrormode(gnupg::ERROR_WARNING); $gpg->import($testkey); $imported = false; foreach (glob("$homedir/*") as $filename) { $imported = true; } var_dump($imported); $engine = $gpg->getengineinfo(); var_dump($engine['home_dir'] === $homedir); ?> --EXPECT-- bool(true) bool(true) --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_keyinfo.phpt0000664000175000017500000000072314163677356017236 0ustar jakubjakub--TEST-- get keyinfo --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg->keyinfo($fingerprint, true); gnupgt::check_keyinfo($gpg->keyinfo($fingerprint), false); gnupgt::check_keyinfo($gpg->keyinfo($fingerprint, true), true); ?> Done --EXPECT-- Done --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_listsignatures.phpt0000664000175000017500000000164514163677356020656 0ustar jakubjakub--TEST-- list signatures --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg->listsignatures($fingerprint); $k1 = "PHP GnuPG "; $k2 = "669E775E0A6284B3"; gnupgt::check_array('PHP GnuPG ', $ret, $k1, $k2, 'uid'); gnupgt::check_array('PHP GnuPG', $ret, $k1, $k2, 'name'); gnupgt::check_array('gnupg@php.net', $ret, $k1, $k2, 'email'); gnupgt::check_array('', $ret, $k1, $k2, 'comment'); gnupgt::check_array(0, $ret, $k1, $k2, 'expires'); gnupgt::check_array(false, $ret, $k1, $k2, 'revoked'); gnupgt::check_array(false, $ret, $k1, $k2, 'expired'); gnupgt::check_array(false, $ret, $k1, $k2, 'invalid'); gnupgt::check_array(1567958444, $ret, $k1, $k2, 'timestamp'); ?> Done --EXPECT-- Done --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_sign_clear.phpt0000664000175000017500000000146114163677356017700 0ustar jakubjakub--TEST--n sign a text with sigmode SIG_MODE_CLEAR --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->setsignmode(gnupg::SIG_MODE_CLEAR); $gpg->addsignkey($fingerprint, $passphrase); $ret = $gpg->sign($plaintext); $gpg = NULL; $gpg = new gnupg(); $tmp = false; $ret = $gpg->verify($ret, false, $tmp); var_dump($ret); var_dump($tmp); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(8) "foo bar " --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_sign_detach.phpt0000664000175000017500000000146414163677356020045 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_DETACH --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->setsignmode(gnupg::SIG_MODE_DETACH); $gpg->addsignkey($fingerprint, $passphrase); $ret = $gpg->sign($plaintext); $gpg = NULL; $gpg = new gnupg(); $tmp = false; $ret = $gpg->verify($plaintext, $ret); var_dump($ret); var_dump($plaintext); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_sign_detach_nonarmor.phpt0000664000175000017500000000154114163677356021754 0ustar jakubjakub--TEST-- sign a text with mode SIG_MODE_DETACH and without armored output --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->setarmor(0); $gpg->setsignmode(gnupg::SIG_MODE_DETACH); $gpg->addsignkey($fingerprint, $passphrase); $ret = $gpg->sign($plaintext); $gpg = NULL; $gpg = new gnupg(); $tmp = false; $ret = $gpg->verify($plaintext, $ret); var_dump($ret); var_dump($plaintext); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_sign_normal.phpt0000664000175000017500000000151614163677356020103 0ustar jakubjakub--TEST-- sign a text with mode SIG_MODE_NORMAL --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->setsignmode(gnupg::SIG_MODE_NORMAL); $gpg->addsignkey($fingerprint, $passphrase); $ret = $gpg->sign($plaintext); $gpg = NULL; $gpg = new gnupg(); $tmp = false; $plaintext = false; $ret = $gpg->verify($ret, false, $plaintext); var_dump($ret); var_dump($plaintext); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_oo_sign_normal_noarmor.phpt0000664000175000017500000000161114163677356021634 0ustar jakubjakub--TEST-- sign a text with mode SIG_MODE_NORMAL and without armored output --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg->setarmor(0); $gpg->setsignmode(gnupg::SIG_MODE_NORMAL); $gpg->addsignkey($fingerprint, $passphrase); $ret = $gpg->sign($plaintext); $gpg = new gnupg(); //$ret = $gpg->verify($plaintext, $ret); $plaintext = false; $ret = $gpg->verify($ret, false, $plaintext); var_dump($ret); var_dump($plaintext); ?> --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_deletekey.phpt0000664000175000017500000000061414163677356017720 0ustar jakubjakub--TEST--n delete a key from the keyring --SKIPIF-- --FILE-- --EXPECT-- bool(true) --CLEAN-- gnupg-1.5.1/tests/gnupg_res_encrypt.phpt0000664000175000017500000000105714163677356017433 0ustar jakubjakub--TEST-- encrypt and decrypt a text --SKIPIF-- --FILE-- --EXPECTF-- string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_encryptsign.phpt0000664000175000017500000000163114163677356020312 0ustar jakubjakub--TEST-- encryptsign and decryptverify a text --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_export.phpt0000664000175000017500000000377514163677356017301 0ustar jakubjakub--TEST-- export a key --SKIPIF-- --FILE-- --EXPECTF-- string(%d) "-----BEGIN PGP PUBLIC KEY BLOCK----- mQENBF11JawBCAC6bWTtKtAj1dBih/UHR9iH1iADEmZde52aKyd7EXKtjs4Q2aXJ kbn9R+kcJNx+AlnTSePQBkNz5brmEAQgk93rOsHaPUEROkfBR2C6AkjaJNnk0E43 pbUy6bWhmGR4kmpbvRnR/7kxVyplb5zSFAcio1I8RQ3ql0HkF//zLUouYzrMJn6e GvffHw1revlSxo0leCcOsNE7AHGVgMxvUWYO0JT4Fs+JcpsTxG8MFE6I6SLZoY5W XmtOsO0vMNJoTaXdqfJoLTkviPkRUZuF0DtzuT1oQLUTTaKvWxx2+33YF5HYrlNy eepLFLh5mZ1/2HFWoQo2X1gFfb1R9EJPbFtJABEBAAG0GVBIUCBHbnVQRyA8Z251 cGdAcGhwLm5ldD6JATgEEwECACIFAl11JawCGwMGCwkIBwMCBhUIAgkKCwQWAgMB Ah4BAheAAAoJEGaed14KYoSzo2QH/AxR9nAqevgbp2GHw+xw4R8XVHMeL2atROFU ndldeYmtVNGh8ck/YSxMz/FY2qLbN3421xOi/ct7nVl77MLZxgZAnsD5qnm0doJl Su/URzUmyhinKLmB9AdklGJNXrL0/dWF0t46Dmv+4W+Qnx3mNhZBUbSW5Ut2pXq0 d4XPTHfkQWgaTPblw97ncQzwVmDSLRqoJEl3yo3OW8/uE1a/ldivuMux5IEcA03l 5L/5g2QOe9cRxk+x9JCXBPqjJ9OIVMUUReGBVSfscGAhnD0bW/aNf5//eGkU9Gai CCSdnIKCopRJSIZcv3OF+P+vh3gmGXAByyQKRvwpBdvosIsiEXi5AQ0EXXUlrAEI AO43Q3D/VgdGGpHa4P0ppv6gY5jBnPHvpyd3Opu497H0z6Xe8rZfRxSpyOViPjF4 NIe2OX6tEAK/hYkH0o91BwbMGAwiljKomL45G4vPb0ve86d/MGrtdeDRt8WhlDEB VfKpxi1bFtq7KvHvnv51iATndM1wE2v79vssMdmJEPRipo+GHiPoThEoO2bdtwI1 thHpUsdXPGpeMcM3F9FmdYpdsFsoyzZ6if7cbijhO4OArGNUm3oJTu66Vok9GjSa V7HsLHJMNf/6Lc66FQSG8+kUKZ/R7s8NY+fS2oFONba3DT5qzA80rfiAFheeAFUz HE3NLkkdPsnzNBOOtRot3bUAEQEAAYkBHwQYAQIACQUCXXUlrAIbDAAKCRBmnnde CmKEs3t+B/4vUc2oXZXuEzIfL7Atv20VJomQCHrsbnNHErqCDJ+TpH6yjcKGGBNR zlOOUpZWFN1Ii2Wml+XIIzOXiOhhH/A6iTTAVl72RQWwiRjm8kYYWThT4msPd5yX QulbZRMxorIIrzs0tjIc5z5FXhSQhIaRjMSKqwJ/VGS9KEWut1F5akJNv/3klMW6 UTIxnj0IMlnL+GaPBf+f1+3Pxoli37aeISxzvLhtquLXc++ls9ICwF6CN9D+Vtp+ H2JaNPDtdHUzVBv0xQ1E3B1XeCiOIDFwWPWvCCY1FbgKXNrn5fdgsk69dLtTGJ4A WU7na8AWygvMcdtuGjpNE4g24ln7Rrce =sQ2w -----END PGP PUBLIC KEY BLOCK----- " --CLEAN-- gnupg-1.5.1/tests/gnupg_res_getengineinfo.phpt0000664000175000017500000000063214163677356020566 0ustar jakubjakub--TEST-- get engineinfo --SKIPIF-- --FILE-- --EXPECTF-- array(3) { ["protocol"]=> int(0) ["file_name"]=> string(%d) %s ["home_dir"]=> string(0) "" } --CLEAN-- gnupg-1.5.1/tests/gnupg_res_geterror.phpt0000664000175000017500000000044214163677356017575 0ustar jakubjakub--TEST-- get error --SKIPIF-- --FILE-- --EXPECT-- bool(false) --CLEAN-- gnupg-1.5.1/tests/gnupg_res_geterrorinfo.phpt0000664000175000017500000000072114163677356020451 0ustar jakubjakub--TEST-- get error info --SKIPIF-- --FILE-- --EXPECT-- array(4) { ["generic_message"]=> bool(false) ["gpgme_code"]=> int(0) ["gpgme_source"]=> string(18) "Unspecified source" ["gpgme_message"]=> string(7) "Success" } --CLEAN-- gnupg-1.5.1/tests/gnupg_res_import.phpt0000664000175000017500000000127114163677356017257 0ustar jakubjakub--TEST-- import a new key into the keyring --SKIPIF-- --FILE-- --EXPECT-- array(9) { ["imported"]=> int(1) ["unchanged"]=> int(0) ["newuserids"]=> int(0) ["newsubkeys"]=> int(0) ["secretimported"]=> int(1) ["secretunchanged"]=> int(0) ["newsignatures"]=> int(0) ["skippedkeys"]=> int(0) ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" } --CLEAN-- gnupg-1.5.1/tests/gnupg_res_init_file_name.phpt0000664000175000017500000000062414163677356020710 0ustar jakubjakub--TEST-- init resource with custom file_name --SKIPIF-- --FILE-- '/usr/bin/gpg')); $engine = gnupg_getengineinfo($gpg); var_dump($engine['file_name']); ?> --EXPECT-- string(12) "/usr/bin/gpg"gnupg-1.5.1/tests/gnupg_res_init_home_dir.phpt0000664000175000017500000000125114163677356020554 0ustar jakubjakub--TEST-- init resource with custom home_dir --SKIPIF-- --FILE-- $homedir)); gnupg_seterrormode($gpg, gnupg::ERROR_WARNING); gnupg_import($gpg, $testkey); $imported = false; foreach (glob("$homedir/*") as $filename) { $imported = true; } var_dump($imported); $engine = gnupg_getengineinfo($gpg); var_dump($engine['home_dir'] === $homedir); ?> --EXPECT-- bool(true) bool(true) --CLEAN-- gnupg-1.5.1/tests/gnupg_res_keyinfo.phpt0000664000175000017500000000075114163677356017413 0ustar jakubjakub--TEST--n get keyinfo --SKIPIF-- --FILE-- Done --EXPECT-- Done --CLEAN-- gnupg-1.5.1/tests/gnupg_res_listsignatures.phpt0000664000175000017500000000166614163677356021035 0ustar jakubjakub--TEST-- list signatures --SKIPIF-- --FILE-- "; $k2 = "669E775E0A6284B3"; gnupgt::check_array('PHP GnuPG ', $ret, $k1, $k2, 'uid'); gnupgt::check_array('PHP GnuPG', $ret, $k1, $k2, 'name'); gnupgt::check_array('gnupg@php.net', $ret, $k1, $k2, 'email'); gnupgt::check_array('', $ret, $k1, $k2, 'comment'); gnupgt::check_array(0, $ret, $k1, $k2, 'expires'); gnupgt::check_array(false, $ret, $k1, $k2, 'revoked'); gnupgt::check_array(false, $ret, $k1, $k2, 'expired'); gnupgt::check_array(false, $ret, $k1, $k2, 'invalid'); gnupgt::check_array(1567958444, $ret, $k1, $k2, 'timestamp'); ?> Done --EXPECT-- Done --CLEAN-- gnupg-1.5.1/tests/gnupg_res_sign_clear.phpt0000664000175000017500000000150614163677356020054 0ustar jakubjakub--TEST--n sign a text with sigmode SIG_MODE_CLEAR --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(8) "foo bar " --CLEAN-- gnupg-1.5.1/tests/gnupg_res_sign_detach.phpt0000664000175000017500000000151014163677356020211 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_DETACH --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_sign_detach_nonarmor.phpt0000664000175000017500000000161314163677356022130 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_DETACH and without armored output --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_sign_normal.phpt0000664000175000017500000000156114163677356020257 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_NORMAL --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupg_res_sign_normal_noarmor.phpt0000664000175000017500000000163014163677356022011 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_NORMAL and without armored output --SKIPIF-- --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "2DF0DD02DC9B70B7F64F572E669E775E0A6284B3" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" --CLEAN-- gnupg-1.5.1/tests/gnupgt.inc0000664000175000017500000001616014163677356015001 0ustar jakubjakubimport($testkey); } /** * Delete all keys. * @param null|string $homeDir */ static public function delete_key($homeDir = null) { if (is_null($homeDir)) { $homeDir = self::get_home_dir(); } if (!is_dir($homeDir)) { return; } foreach (glob($homeDir . '/*') as $filename) { if (!is_dir($filename)) { unlink($filename); } } $privKeyDir = self::get_priv_key_dir($homeDir); if (is_dir($privKeyDir)) { foreach (glob($privKeyDir . '/*') as $key) { unlink($key); } rmdir($privKeyDir); } rmdir($homeDir); } /** * Initialize key directory. */ static public function init_key_dir() { mkdir(self::get_home_dir()); mkdir(self::get_priv_key_dir(), 0700); } /** * Reset all keys. */ static public function reset_key() { self::delete_key(); self::init_key_dir(); } /** * Get home directory. * * @return string */ static private function get_home_dir() { return __DIR__ . '/home'; } /** * Get private key directory (for GPG2). * @param null|string $homeDir * @return string */ static private function get_priv_key_dir($homeDir = null) { if (is_null($homeDir)) { $homeDir = self::get_home_dir(); } return $homeDir . '/private-keys-v1.d'; } /** * Print error message and return false. * * @param string $msg * @return bool */ static private function error($msg) { echo "ERROR: " . $msg; return false; } /** * Check single array value. * * @param mixed $expected * @param array $a * @param string $key1 * @return bool */ static public function check_array($expected, $a, $key1) { $args = func_get_args(); $keys = array_splice($args, 2); $value = $a; foreach ($keys as $key) { if (!isset($value[$key])) { return self::error("key $key not found in the array"); } $value = $value[$key]; } if ($value !== $expected) { return self::error( sprintf( "key %s value %s does not match expected %s\n", $key, var_export($value, true), var_export($expected, true) ) ); } return true; } /** * Check single array value but only for GpgME version higher than supplied. * * @param mixed $expected * @param array $a * @param string $key1 * @return bool */ static public function check_array_from_version($version, $expected, $a, $key1) { if (version_compare(GNUPG_GPGME_VERSION, $version) < 0) { return true; } $args = func_get_args(); return call_user_func_array('gnupgt::check_array', array_splice($args, 1)); } /** * Check keyinfo for var key * * @param $ret * @param $secret_only */ static public function check_keyinfo($ret, $secret_only) { self::check_array(false, $ret, 0, 'disabled'); self::check_array(false, $ret, 0, 'expired'); self::check_array(false, $ret, 0, 'revoked'); self::check_array($secret_only, $ret, 0, 'is_secret'); self::check_array(true, $ret, 0, 'can_sign'); self::check_array(true, $ret, 0, 'can_encrypt'); // uid self::check_array('PHP GnuPG', $ret, 0, 'uids', 0, 'name'); self::check_array('', $ret, 0, 'uids', 0, 'comment'); self::check_array('gnupg@php.net', $ret, 0, 'uids', 0, 'email'); self::check_array('PHP GnuPG ', $ret, 0, 'uids', 0, 'uid'); self::check_array(false, $ret, 0, 'uids', 0, 'revoked'); self::check_array(false, $ret, 0, 'uids', 0, 'invalid'); self::check_array(false, $ret, 0, 'uids', 0, 'invalid'); // subkey 1 self::check_array("2DF0DD02DC9B70B7F64F572E669E775E0A6284B3", $ret, 0, 'subkeys', 0, 'fingerprint'); self::check_array("669E775E0A6284B3", $ret, 0, 'subkeys', 0, 'keyid'); self::check_array(1567958444, $ret, 0, 'subkeys', 0, 'timestamp'); self::check_array(0, $ret, 0, 'subkeys', 0, 'expires'); self::check_array($secret_only, $ret, 0, 'subkeys', 0, 'is_secret'); self::check_array(false, $ret, 0, 'subkeys', 0, 'can_encrypt'); self::check_array(true, $ret, 0, 'subkeys', 0, 'can_sign'); self::check_array(false, $ret, 0, 'subkeys', 0, 'disabled'); self::check_array(false, $ret, 0, 'subkeys', 0, 'expired'); self::check_array(false, $ret, 0, 'subkeys', 0, 'revoked'); self::check_array(true, $ret, 0, 'subkeys', 0, 'can_certify'); self::check_array(false, $ret, 0, 'subkeys', 0, 'can_authenticate'); self::check_array(false, $ret, 0, 'subkeys', 0, 'is_qualified'); // TODO: The is_de_vs seems to differ between gpg2 (true) and gpg1 (false) - differenatiate the test //self::check_array_from_version('1.9.0', true, $ret, 0, 'subkeys', 0, 'is_de_vs'); self::check_array(GNUPG_PK_RSA, $ret, 0, 'subkeys', 0, 'pubkey_algo'); self::check_array(2048, $ret, 0, 'subkeys', 0, 'length'); self::check_array_from_version('1.7.0', false, $ret, 0, 'subkeys', 0, 'is_cardkey'); // subkey 2 self::check_array("9E84AE800874DFF647B6062B46DCA9B3662C7DFC", $ret, 0, 'subkeys', 1, 'fingerprint'); self::check_array("46DCA9B3662C7DFC", $ret, 0, 'subkeys', 1, 'keyid'); self::check_array(1567958444, $ret, 0, 'subkeys', 1, 'timestamp'); self::check_array(0, $ret, 0, 'subkeys', 1, 'expires'); self::check_array($secret_only, $ret, 0, 'subkeys', 1, 'is_secret'); self::check_array(true, $ret, 0, 'subkeys', 1, 'can_encrypt'); self::check_array(false, $ret, 0, 'subkeys', 1, 'can_sign'); self::check_array(false, $ret, 0, 'subkeys', 1, 'disabled'); self::check_array(false, $ret, 0, 'subkeys', 1, 'expired'); self::check_array(false, $ret, 0, 'subkeys', 1, 'revoked'); self::check_array(false, $ret, 0, 'subkeys', 1, 'can_certify'); self::check_array(false, $ret, 0, 'subkeys', 1, 'can_authenticate'); self::check_array(false, $ret, 0, 'subkeys', 1, 'is_qualified'); // TODO: The is_de_vs seems to differ between gpg2 (true) and gpg1 (false) - differenatiate the test // self::check_array_from_version('1.9.0', true, $ret, 0, 'subkeys', 1, 'is_de_vs'); self::check_array(GNUPG_PK_RSA, $ret, 0, 'subkeys', 1, 'pubkey_algo'); self::check_array(2048, $ret, 0, 'subkeys', 1, 'length'); self::check_array_from_version('1.7.0', false, $ret, 0, 'subkeys', 1, 'is_cardkey'); } } gnupg-1.5.1/tests/vars.inc0000664000175000017500000000730214163677356014446 0ustar jakubjakub gnupg-1.5.1/config.m40000664000175000017500000000421114163677356013341 0ustar jakubjakubdnl config.m4 for extension gnupg AC_CANONICAL_HOST case $host_os in *BSD* | *bsd) GNUPG_DL="" ;; *) GNUPG_DL="-ldl" ;; esac PHP_ARG_WITH(gnupg, for gnupg support, [ --with-gnupg[=dir] Include gnupg support]) if test "$PHP_GNUPG" != "no"; then SEARCH_PATH="/usr/local /usr /opt" SEARCH_FOR="include/gpgme.h" SEARCH_FOR_ALT="include/gpgme/gpgme.h" if test -r $PHP_GNUPG/$SEARCH_FOR; then GNUPG_DIR=$PHP_GNUPG else 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 if test -r $i/$SEARCH_FOR_ALT; 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 gpgme distribution]) fi PHP_ADD_INCLUDE($GNUPG_DIR/include) dnl enable largefile support on 32-bits platform AC_SYS_LARGEFILE AC_TYPE_OFF_T dnl gpgme_op_passwd is not used but was added in 1.3.0 LIBNAME=gpgme LIBSYMBOL=gpgme_op_passwd PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL, [ PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $GNUPG_DIR/$PHP_LIBDIR, GNUPG_SHARED_LIBADD) AC_DEFINE(HAVE_GNUPGLIB,1,[ ]) ],[ AC_MSG_ERROR([wrong gpgme lib version or lib not found (version >= 1.3 required)]) ],[ -L$GNUPG_DIR/$PHP_LIBDIR -lm $GNUPG_DL ]) PHP_SUBST(GNUPG_SHARED_LIBADD) PHP_NEW_EXTENSION(gnupg, [gnupg.c gnupg_keylistiterator.c], $ext_shared) fi AC_ARG_WITH([gpg], [AS_HELP_STRING([--with-gpg], [path to gpg v1.x])], [], [with_gpg=no]) AC_PATH_PROG(GNUPG_PATH, gpg) if test "$with_gpg" != "no"; then if test "$with_gpg" != "yes"; then if test -x "$with_gpg"; then ac_cv_path_GNUPG_PATH=$with_gpg else if test -x "$ac_cv_path_GNUPG_PATH"; then AC_MSG_RESULT($with_gpg invalid: using $ac_cv_path_GNUPG_PATH) else AC_MSG_RESULT($with_gpg invalid) fi fi fi if test -x "$ac_cv_path_GNUPG_PATH"; then AC_DEFINE_UNQUOTED([GNUPG_PATH], ["$ac_cv_path_GNUPG_PATH"], [Path to gpg binary]) fi fi gnupg-1.5.1/EXPERIMENTAL0000664000175000017500000000000014163677356013442 0ustar jakubjakubgnupg-1.5.1/gnupg.c0000664000175000017500000016402214163677356013125 0ustar jakubjakub/* +--------------------------------------------------------------------+ | PECL :: gnupg | +--------------------------------------------------------------------+ | Redistribution and use in source and binary forms, with or without | | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ | Copyright (c) 2006, Thilo Raufeisen | | Copyright (c) 2013, Jim Jagielski | | Copyright (c) 2016, Jakub Zelenka | +--------------------------------------------------------------------+ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include "php.h" #include "php_ini.h" #include "zend_exceptions.h" #include "ext/standard/info.h" #include "php_gnupg.h" #include "phpc/phpc.h" #include "php_gnupg_keylistiterator.h" static int le_gnupg; static zend_class_entry *gnupg_class_entry; PHPC_OBJ_DEFINE_HANDLER_VAR(gnupg); /* {{{ GNUPG_GETOBJ */ #define GNUPG_GETOBJ() \ zval *this = getThis(); \ PHPC_THIS_DECLARE(gnupg) = NULL; \ zval *res; \ do { \ if (this) { \ PHPC_THIS_FETCH_FROM_ZVAL(gnupg, this); \ if (!PHPC_THIS) { \ php_error_docref(NULL TSRMLS_CC, E_WARNING, \ "Invalid or unitialized gnupg object"); \ RETURN_FALSE; \ } \ } \ } while (0) /* }}} */ #define GNUPG_RES_FETCH() \ PHPC_THIS = (PHPC_OBJ_STRUCT_NAME(gnupg) *) \ PHPC_RES_FETCH(res, "ctx", le_gnupg) /* {{{ GNUPG_ERR */ #define GNUPG_ERR(error) \ if (PHPC_THIS) { \ switch (PHPC_THIS->errormode) { \ case 1: \ php_error_docref(NULL TSRMLS_CC, E_WARNING, \ (char*)error); \ break; \ case 2: \ zend_throw_exception(\ zend_exception_get_default(TSRMLS_C), \ (char*) error, \ 0 TSRMLS_CC \ ); \ break; \ default: \ PHPC_THIS->errortxt = (char*)error; \ } \ } else { \ php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \ } \ do { \ if (return_value) { \ RETVAL_FALSE; \ } \ } while (0) /* }}} */ /* {{{ php_gnupg_free_encryptkeys */ static void php_gnupg_free_encryptkeys(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC) { if (PHPC_THIS) { int idx; /* loop through all encryptkeys and unref them in the gpgme-lib */ for (idx = 0; idx < PHPC_THIS->encrypt_size; idx++) { gpgme_key_unref(PHPC_THIS->encryptkeys[idx]); } if (PHPC_THIS->encryptkeys != NULL) { efree(PHPC_THIS->encryptkeys); } PHPC_THIS->encryptkeys = NULL; PHPC_THIS->encrypt_size = 0; } } /* }}} */ /* {{{ php_gnupg_this_free */ static void php_gnupg_this_free(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC) { if (PHPC_THIS) { if (PHPC_THIS->ctx) { /* clear all signers from the gpgme-lib and finally release it */ gpgme_signers_clear(PHPC_THIS->ctx); gpgme_release(PHPC_THIS->ctx); PHPC_THIS->ctx = NULL; } /* basic cleanup */ php_gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC); zend_hash_destroy(PHPC_THIS->signkeys); FREE_HASHTABLE(PHPC_THIS->signkeys); zend_hash_destroy(PHPC_THIS->decryptkeys); FREE_HASHTABLE(PHPC_THIS->decryptkeys); } } /* }}} */ /* {{{ php_gnupg_this_init */ static void php_gnupg_this_init(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC) { /* init the gpgme-lib and set the default values */ gpgme_ctx_t ctx; gpgme_error_t err; err = gpgme_new(&ctx); PHPC_THIS->ctx = ctx; PHPC_THIS->encryptkeys = NULL; PHPC_THIS->encrypt_size = 0; PHPC_THIS->signmode = GPGME_SIG_MODE_CLEAR; PHPC_THIS->err = err; PHPC_THIS->errortxt = NULL; PHPC_THIS->errormode = 3; ALLOC_HASHTABLE(PHPC_THIS->signkeys); zend_hash_init(PHPC_THIS->signkeys, 0, NULL, NULL, 0); ALLOC_HASHTABLE(PHPC_THIS->decryptkeys); zend_hash_init(PHPC_THIS->decryptkeys, 0, NULL, NULL, 0); } /* }}} */ /* set GNUPG_PATH to NULL if not defined */ #ifndef GNUPG_PATH #define GNUPG_PATH NULL #endif /* {{{ php_gnupg_this_make */ static void php_gnupg_this_make(PHPC_THIS_DECLARE(gnupg), zval *options TSRMLS_DC) { if (PHPC_THIS->err == GPG_ERR_NO_ERROR) { char *file_name = GNUPG_PATH; char *home_dir = NULL; phpc_val *ppv_file_name, *ppv_home_dir; gpgme_ctx_t ctx = PHPC_THIS->ctx; if (options && PHPC_HASH_CSTR_FIND_IN_COND( Z_ARRVAL_P(options), "file_name", ppv_file_name)) { file_name = PHPC_STRVAL_P(ppv_file_name); } if (options && PHPC_HASH_CSTR_FIND_IN_COND( Z_ARRVAL_P(options), "home_dir", ppv_home_dir)) { home_dir = PHPC_STRVAL_P(ppv_home_dir); } if (file_name != NULL || home_dir != NULL) { gpgme_ctx_set_engine_info( ctx, GPGME_PROTOCOL_OpenPGP, file_name, home_dir); } gpgme_set_armor(ctx, 1); #if GPGME_VERSION_NUMBER >= 0x010400 /* GPGME >= 1.4.0 */ gpgme_set_pinentry_mode(ctx, GPGME_PINENTRY_MODE_LOOPBACK); #endif } } /* }}} */ /* {{{ php_gnupg_res_dtor */ static void php_gnupg_res_dtor(phpc_res_entry_t *rsrc TSRMLS_DC) /* {{{ */ { PHPC_THIS_DECLARE(gnupg) = rsrc->ptr; php_gnupg_this_free(PHPC_THIS TSRMLS_CC); efree(PHPC_THIS); } /* }}} */ /* {{{ free gnupg */ PHPC_OBJ_HANDLER_FREE(gnupg) { PHPC_OBJ_HANDLER_FREE_INIT(gnupg); php_gnupg_this_free(PHPC_THIS TSRMLS_CC); PHPC_OBJ_HANDLER_FREE_DESTROY(); } /* {{{ create_ex gnupg */ PHPC_OBJ_HANDLER_CREATE_EX(gnupg) { PHPC_OBJ_HANDLER_CREATE_EX_INIT(gnupg); php_gnupg_this_init(PHPC_THIS TSRMLS_CC); PHPC_OBJ_HANDLER_CREATE_EX_RETURN(gnupg); } /* {{{ create gnupg */ PHPC_OBJ_HANDLER_CREATE(gnupg) { PHPC_OBJ_HANDLER_CREATE_RETURN(gnupg); } /* {{{ arginfo for gnupg __construct and gnupg_init */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_init, 0, 0, 0) ZEND_ARG_INFO(0, options) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg void methods */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_void_method, 0, 0, 0) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg method with armor parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_armor_method, 0) ZEND_ARG_INFO(0, armor) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with enctext parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_enctext_method, 0) ZEND_ARG_INFO(0, enctext) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with text parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_text_method, 0) ZEND_ARG_INFO(0, text) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with key parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_key_method, 0) ZEND_ARG_INFO(0, kye) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with adddecryptkey parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_key_passphrase_method, 0) ZEND_ARG_INFO(0, kye) ZEND_ARG_INFO(0, passphrase) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with deletekey parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_deletekey_method, 0) ZEND_ARG_INFO(0, kye) ZEND_ARG_INFO(0, allow_secret) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with key parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_keyid_method, 0) ZEND_ARG_INFO(0, kyeid) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg_keyinfo method */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_keyinfo_method, 0, 0, 1) ZEND_ARG_INFO(0, pattern) ZEND_ARG_INFO(0, secret_only) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with pattern parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_pattern_method, 0) ZEND_ARG_INFO(0, pattern) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with errmode parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_errmode_method, 0) ZEND_ARG_INFO(0, errnmode) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg methods with signmode parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_signmode_method, 0) ZEND_ARG_INFO(0, signmode) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg_verify method */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_method, 0, 0, 2) ZEND_ARG_INFO(0, text) ZEND_ARG_INFO(0, signature) ZEND_ARG_INFO(1, plaintext) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg_decryptverify method */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_decryptverify_method, 0, 0, 2) ZEND_ARG_INFO(0, enctext) ZEND_ARG_INFO(1, plaintext) ZEND_END_ARG_INFO() /* }}} */ #define PHP_GNUPG_FALIAS(_name, _arginfo) \ PHP_FALIAS(_name, gnupg_ ## _name, _arginfo) /* {{{ methodlist gnupg */ phpc_function_entry gnupg_methods[] = { PHP_ME(gnupg, __construct, arginfo_gnupg_init, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC) PHP_GNUPG_FALIAS(keyinfo, arginfo_gnupg_keyinfo_method) PHP_GNUPG_FALIAS(verify, arginfo_gnupg_verify_method) PHP_GNUPG_FALIAS(getengineinfo, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(geterror, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(geterrorinfo, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(clearsignkeys, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(clearencryptkeys, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(cleardecryptkeys, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(setarmor, arginfo_gnupg_armor_method) PHP_GNUPG_FALIAS(encrypt, arginfo_gnupg_text_method) PHP_GNUPG_FALIAS(decrypt, arginfo_gnupg_enctext_method) PHP_GNUPG_FALIAS(export, arginfo_gnupg_pattern_method) PHP_GNUPG_FALIAS(import, arginfo_gnupg_key_method) PHP_GNUPG_FALIAS(getprotocol, arginfo_gnupg_void_method) PHP_GNUPG_FALIAS(setsignmode, arginfo_gnupg_signmode_method) PHP_GNUPG_FALIAS(sign, arginfo_gnupg_text_method) PHP_GNUPG_FALIAS(encryptsign, arginfo_gnupg_text_method) PHP_GNUPG_FALIAS(decryptverify, arginfo_gnupg_decryptverify_method) PHP_GNUPG_FALIAS(addsignkey, arginfo_gnupg_key_passphrase_method) PHP_GNUPG_FALIAS(addencryptkey, arginfo_gnupg_key_method) PHP_GNUPG_FALIAS(adddecryptkey, arginfo_gnupg_key_passphrase_method) PHP_GNUPG_FALIAS(deletekey, arginfo_gnupg_deletekey_method) PHP_GNUPG_FALIAS(gettrustlist, arginfo_gnupg_pattern_method) PHP_GNUPG_FALIAS(listsignatures, arginfo_gnupg_keyid_method) PHP_GNUPG_FALIAS(seterrormode, arginfo_gnupg_errmode_method) PHPC_FE_END }; /* }}} */ /* {{{ arginfo for gnupg function with no parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_void_function, 0) ZEND_ARG_INFO(0, res) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg init */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_init_function, 0, 0, 0) ZEND_ARG_INFO(0, options) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg function with armor parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_armor_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, armor) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with enctext parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_enctext_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, enctext) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with text parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_text_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, text) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with key parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_key_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, kye) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with deletekey parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_deletekey_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, kye) ZEND_ARG_INFO(0, allow_secret) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with adddecryptkey parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_key_passphrase_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, kye) ZEND_ARG_INFO(0, passphrase) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with key parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_keyid_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, kyeid) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with pattern parameter */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_keyinfo_function, 0, 0, 2) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, pattern) ZEND_ARG_INFO(0, secret_only) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with pattern parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_pattern_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, pattern) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with errmode parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_errmode_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, errnmode) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo for gnupg functions with signmode parameter */ ZEND_BEGIN_ARG_INFO(arginfo_gnupg_signmode_function, 0) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, signmode) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo gnupg_verify_function */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_verify_function, 0, 0, 3) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, text) ZEND_ARG_INFO(0, signature) ZEND_ARG_INFO(1, plaintext) ZEND_END_ARG_INFO() /* }}} */ /* {{{ arginfo gnupg_decryptverify_function */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_decryptverify_function, 0, 0, 3) ZEND_ARG_INFO(0, res) ZEND_ARG_INFO(0, enctext) ZEND_ARG_INFO(1, plaintext) ZEND_END_ARG_INFO() /* }}} */ /* {{{ functionlist gnupg */ static zend_function_entry gnupg_functions[] = { PHP_FE(gnupg_init, arginfo_gnupg_init_function) PHP_FE(gnupg_keyinfo, arginfo_gnupg_keyinfo_function) PHP_FE(gnupg_sign, arginfo_gnupg_text_function) PHP_FE(gnupg_verify, arginfo_gnupg_verify_function) PHP_FE(gnupg_clearsignkeys, arginfo_gnupg_void_function) PHP_FE(gnupg_clearencryptkeys, arginfo_gnupg_void_function) PHP_FE(gnupg_cleardecryptkeys, arginfo_gnupg_void_function) PHP_FE(gnupg_setarmor, arginfo_gnupg_armor_function) PHP_FE(gnupg_encrypt, arginfo_gnupg_text_function) PHP_FE(gnupg_decrypt, arginfo_gnupg_enctext_function) PHP_FE(gnupg_export, arginfo_gnupg_pattern_function) PHP_FE(gnupg_import, arginfo_gnupg_key_function) PHP_FE(gnupg_getengineinfo, arginfo_gnupg_void_function) PHP_FE(gnupg_getprotocol, arginfo_gnupg_void_function) PHP_FE(gnupg_setsignmode, arginfo_gnupg_signmode_function) PHP_FE(gnupg_encryptsign, arginfo_gnupg_text_function) PHP_FE(gnupg_decryptverify, arginfo_gnupg_decryptverify_function) PHP_FE(gnupg_geterror, arginfo_gnupg_void_function) PHP_FE(gnupg_geterrorinfo, arginfo_gnupg_void_function) PHP_FE(gnupg_addsignkey, arginfo_gnupg_key_passphrase_function) PHP_FE(gnupg_addencryptkey, arginfo_gnupg_key_function) PHP_FE(gnupg_adddecryptkey, arginfo_gnupg_key_passphrase_function) PHP_FE(gnupg_deletekey, arginfo_gnupg_deletekey_function) PHP_FE(gnupg_gettrustlist, arginfo_gnupg_pattern_function) PHP_FE(gnupg_listsignatures, arginfo_gnupg_keyid_function) PHP_FE(gnupg_seterrormode, arginfo_gnupg_errmode_function) PHPC_FE_END }; /* }}} */ /* {{{ gnupg_module_entry */ zend_module_entry gnupg_module_entry = { STANDARD_MODULE_HEADER, "gnupg", gnupg_functions, PHP_MINIT(gnupg), PHP_MSHUTDOWN(gnupg), NULL, NULL, PHP_MINFO(gnupg), PHP_GNUPG_VERSION, STANDARD_MODULE_PROPERTIES }; /* }}} */ #ifdef COMPILE_DL_GNUPG ZEND_GET_MODULE(gnupg) #endif #define PHP_GNUPG_DO(_action) ((PHPC_THIS->err = _action) == GPG_ERR_NO_ERROR) #define PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL_EX(_g_arr, _g_name, _g_struct, _g_key) \ PHPC_ARRAY_ADD_ASSOC_BOOL(\ PHPC_VAL_CAST_TO_PZVAL(_g_arr), #_g_name, _g_struct->_g_key) #define PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(_g_arr, _g_name, _g_struct) \ PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL_EX(_g_arr, _g_name, _g_struct, _g_name) #define PHP_GNUPG_ARRAY_ADD_ASSOC_LONG_EX(_g_arr, _g_name, _g_struct, _g_key) \ PHPC_ARRAY_ADD_ASSOC_LONG(\ PHPC_VAL_CAST_TO_PZVAL(_g_arr), #_g_name, _g_struct->_g_key) #define PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(_g_arr, _g_name, _g_struct) \ PHP_GNUPG_ARRAY_ADD_ASSOC_LONG_EX(_g_arr, _g_name, _g_struct, _g_name) #define PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR_EX(_g_arr, _g_name, _g_struct, _g_key) \ PHPC_ARRAY_ADD_ASSOC_CSTR(\ PHPC_VAL_CAST_TO_PZVAL(_g_arr), #_g_name, _g_struct->_g_key) #define PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(_g_arr, _g_name, _g_struct) \ PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR_EX(_g_arr, _g_name, _g_struct, _g_name) #define PHP_GNUPG_SET_CLASS_CONST(_name, _value) \ zend_declare_class_constant_long(gnupg_class_entry, \ _name, sizeof(_name) - 1, _value TSRMLS_CC) #define PHP_GNUPG_REG_CONST(_name, _value) \ REGISTER_LONG_CONSTANT(_name, _value, CONST_CS | CONST_PERSISTENT); #define PHP_GNUPG_REG_CONST_STR(_name, _value) \ REGISTER_STRING_CONSTANT(_name, _value, CONST_CS | CONST_PERSISTENT); #define PHP_GNUPG_VERSION_BUF_SIZE 64 /* {{{ PHP_MINIT_FUNCTION */ PHP_MINIT_FUNCTION(gnupg) { zend_class_entry ce; char php_gpgme_version[PHP_GNUPG_VERSION_BUF_SIZE]; /* init class */ INIT_CLASS_ENTRY(ce, "gnupg", gnupg_methods); PHPC_CLASS_SET_HANDLER_CREATE(ce, gnupg); gnupg_class_entry = PHPC_CLASS_REGISTER(ce); PHPC_OBJ_INIT_HANDLERS(gnupg); PHPC_OBJ_SET_HANDLER_OFFSET(gnupg); PHPC_OBJ_SET_HANDLER_FREE(gnupg); /* register resource */ le_gnupg = zend_register_list_destructors_ex( php_gnupg_res_dtor, NULL, "ctx", module_number); if (SUCCESS != gnupg_keylistiterator_init()) { return FAILURE; } PHP_GNUPG_SET_CLASS_CONST("SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL); PHP_GNUPG_SET_CLASS_CONST("SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH); PHP_GNUPG_SET_CLASS_CONST("SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_NEVER", GPGME_VALIDITY_NEVER); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_FULL", GPGME_VALIDITY_FULL); PHP_GNUPG_SET_CLASS_CONST("VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE); PHP_GNUPG_SET_CLASS_CONST("PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP); PHP_GNUPG_SET_CLASS_CONST("PROTOCOL_CMS", GPGME_PROTOCOL_CMS); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_VALID", GPGME_SIGSUM_VALID); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_GREEN", GPGME_SIGSUM_GREEN); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_RED", GPGME_SIGSUM_RED); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY); PHP_GNUPG_SET_CLASS_CONST("SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR); PHP_GNUPG_SET_CLASS_CONST("ERROR_WARNING", 1); PHP_GNUPG_SET_CLASS_CONST("ERROR_EXCEPTION", 2); PHP_GNUPG_SET_CLASS_CONST("ERROR_SILENT", 3); PHP_GNUPG_SET_CLASS_CONST("PK_RSA", GPGME_PK_RSA); PHP_GNUPG_SET_CLASS_CONST("PK_RSA_E", GPGME_PK_RSA_E); PHP_GNUPG_SET_CLASS_CONST("PK_RSA_S", GPGME_PK_RSA_S); PHP_GNUPG_SET_CLASS_CONST("PK_DSA", GPGME_PK_DSA); PHP_GNUPG_SET_CLASS_CONST("PK_ELG", GPGME_PK_ELG); PHP_GNUPG_SET_CLASS_CONST("PK_ELG_E", GPGME_PK_ELG_E); #if GPGME_VERSION_NUMBER >= 0x010500 /* GPGME >= 1.5.0 */ PHP_GNUPG_SET_CLASS_CONST("PK_ECC", GPGME_PK_ECC); #endif /* gpgme >= 1.5.0 */ PHP_GNUPG_SET_CLASS_CONST("PK_ECDSA", GPGME_PK_ECDSA); PHP_GNUPG_SET_CLASS_CONST("PK_ECDH", GPGME_PK_ECDH); #if GPGME_VERSION_NUMBER >= 0x010700 /* GPGME >= 1.7.0 */ PHP_GNUPG_SET_CLASS_CONST("PK_EDDSA", GPGME_PK_EDDSA); #endif /* gpgme >= 1.7.0 */ PHP_GNUPG_REG_CONST("GNUPG_SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL); PHP_GNUPG_REG_CONST("GNUPG_SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH); PHP_GNUPG_REG_CONST("GNUPG_SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_NEVER", GPGME_VALIDITY_NEVER); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_FULL", GPGME_VALIDITY_FULL); PHP_GNUPG_REG_CONST("GNUPG_VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE); PHP_GNUPG_REG_CONST("GNUPG_PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP); PHP_GNUPG_REG_CONST("GNUPG_PROTOCOL_CMS", GPGME_PROTOCOL_CMS); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_VALID", GPGME_SIGSUM_VALID); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_GREEN", GPGME_SIGSUM_GREEN); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_RED", GPGME_SIGSUM_RED); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY); PHP_GNUPG_REG_CONST("GNUPG_SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR); PHP_GNUPG_REG_CONST("GNUPG_ERROR_WARNING", 1); PHP_GNUPG_REG_CONST("GNUPG_ERROR_EXCEPTION", 2); PHP_GNUPG_REG_CONST("GNUPG_ERROR_SILENT", 3); PHP_GNUPG_REG_CONST("GNUPG_PK_RSA", GPGME_PK_RSA); PHP_GNUPG_REG_CONST("GNUPG_PK_RSA_E", GPGME_PK_RSA_E); PHP_GNUPG_REG_CONST("GNUPG_PK_RSA_S", GPGME_PK_RSA_S); PHP_GNUPG_REG_CONST("GNUPG_PK_DSA", GPGME_PK_DSA); PHP_GNUPG_REG_CONST("GNUPG_PK_ELG", GPGME_PK_ELG); PHP_GNUPG_REG_CONST("GNUPG_PK_ELG_E", GPGME_PK_ELG_E); #if GPGME_VERSION_NUMBER >= 0x010500 /* GPGME >= 1.5.0 */ PHP_GNUPG_REG_CONST("GNUPG_PK_ECC", GPGME_PK_ECC); #endif /* gpgme >= 1.5.0 */ PHP_GNUPG_REG_CONST("GNUPG_PK_ECDSA", GPGME_PK_ECDSA); PHP_GNUPG_REG_CONST("GNUPG_PK_ECDH", GPGME_PK_ECDH); #if GPGME_VERSION_NUMBER >= 0x010700 /* GPGME >= 1.7.0 */ PHP_GNUPG_REG_CONST("GNUPG_PK_EDDSA", GPGME_PK_EDDSA); #endif /* gpgme >= 1.7.0 */ /* init gpgme subsystems and set the returned version to the constant */ strncpy(php_gpgme_version, gpgme_check_version(NULL), PHP_GNUPG_VERSION_BUF_SIZE); php_gpgme_version[PHP_GNUPG_VERSION_BUF_SIZE - 1] = '\0'; PHP_GNUPG_REG_CONST_STR("GNUPG_GPGME_VERSION", php_gpgme_version); return SUCCESS; } /* }}} */ /* {{{ PHP_MSHUTDOWN_FUNCTION */ PHP_MSHUTDOWN_FUNCTION(gnupg) { return SUCCESS; } /* }}} */ /* {{{ PHP_MINFO_FUNCTION */ PHP_MINFO_FUNCTION(gnupg) { const char *php_gpgme_version = gpgme_check_version(NULL); php_info_print_table_start(); php_info_print_table_header(2, "gnupg support", "enabled"); 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_end(); } /* }}} */ /* {{{ passphrase_cb */ gpgme_error_t passphrase_cb( void *hook, const char *uid_hint, const char *passphrase_info, int last_was_bad, int fd) { char uid[17]; int idx; char *passphrase = NULL; zval *return_value = NULL; PHPC_THIS_DECLARE(gnupg) = hook; TSRMLS_FETCH(); if (last_was_bad) { GNUPG_ERR("Incorrent passphrase"); return 1; } for (idx=0; idx < 16; idx++) { uid[idx] = uid_hint[idx]; } uid[16] = '\0'; if (!PHPC_HASH_CSTR_FIND_PTR_IN_COND( PHPC_THIS->signkeys, (char *)uid, passphrase)) { GNUPG_ERR("no passphrase set"); return 1; } if (!passphrase) { GNUPG_ERR("no passphrase set"); return 1; } if (write(fd, passphrase, strlen(passphrase)) == strlen(passphrase) && write(fd, "\n", 1) == 1) { return 0; } GNUPG_ERR("write failed"); return 1; } /* }}} */ /* {{{ passphrase_decrypt_cb */ gpgme_error_t passphrase_decrypt_cb ( void *hook, const char *uid_hint, const char *passphrase_info, int last_was_bad, int fd) { char uid[17]; int idx; char *passphrase = NULL; zval *return_value = NULL; PHPC_THIS_DECLARE(gnupg) = hook; TSRMLS_FETCH(); if (last_was_bad) { GNUPG_ERR("Incorrent passphrase"); return 1; } for (idx=0; idx < 16; idx++) { uid[idx] = uid_hint[idx]; } uid[16] = '\0'; if (!PHPC_HASH_CSTR_FIND_PTR_IN_COND( PHPC_THIS->decryptkeys, (char *)uid, passphrase)) { GNUPG_ERR("no passphrase set"); return 1; } if (!passphrase) { GNUPG_ERR("no passphrase set"); return 1; } if (write(fd, passphrase, strlen(passphrase)) == strlen(passphrase) && write(fd, "\n", 1) == 1) { return 0; } GNUPG_ERR("write failed"); return 1; } /* }}} */ /* {{{ gnupg_fetchsignatures */ int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr) { phpc_val sig_arr; PHPC_ARRAY_INIT(main_arr); while (gpgme_signatures) { PHPC_VAL_MAKE(sig_arr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(sig_arr)); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR_EX(sig_arr, fingerprint, gpgme_signatures, fpr); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, validity, gpgme_signatures); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, timestamp, gpgme_signatures); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, status, gpgme_signatures); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, summary, gpgme_signatures); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL( main_arr, PHPC_VAL_CAST_TO_PZVAL(sig_arr) ); gpgme_signatures = gpgme_signatures->next; } return 1; } /* }}} */ /* {{{ proto gnupg::__construct(array options = NULL) * inits gnupg and returns a resource */ PHP_METHOD(gnupg, __construct) { zval *options = NULL; PHPC_THIS_DECLARE(gnupg); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &options) == FAILURE) { return; } PHPC_THIS_FETCH(gnupg); php_gnupg_this_make(PHPC_THIS, options TSRMLS_CC); } /* }}} */ /* {{{ proto resource gnupg_init(array options = NULL) * inits gnupg and returns a resource */ PHP_FUNCTION(gnupg_init) { zval *options = NULL; PHPC_THIS_DECLARE(gnupg); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &options) == FAILURE) { return; } PHPC_THIS = emalloc(sizeof(PHPC_OBJ_STRUCT_NAME(gnupg))); php_gnupg_this_init(PHPC_THIS TSRMLS_CC); php_gnupg_this_make(PHPC_THIS, options TSRMLS_CC); PHPC_RES_RETURN(PHPC_RES_REGISTER(PHPC_THIS, le_gnupg)); } /* }}} */ /* {{{ proto bool gnupg_setarmor(int armor) * turn on/off armor mode * 0 = off * >0 = on * */ PHP_FUNCTION(gnupg_setarmor) { phpc_long_t armor; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &armor) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (armor > 1) { armor = 1; /*just to make sure */ } gpgme_set_armor(PHPC_THIS->ctx, armor); RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_seterrormode(int errormde) */ PHP_FUNCTION(gnupg_seterrormode) { phpc_long_t errormode; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &errormode) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE) { return; } GNUPG_RES_FETCH(); } switch (errormode) { case 1: /* warning */ case 3: /* silent */ PHPC_THIS->errormode = errormode; break; case 2: /* exception */ PHPC_THIS->errormode = errormode; break; default: GNUPG_ERR("invalid errormode"); } RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_setsignmode(int signmode) * sets the mode for signing operations */ PHP_FUNCTION(gnupg_setsignmode) { phpc_long_t signmode; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &signmode) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE) { return; } GNUPG_RES_FETCH(); } switch (signmode) { case GPGME_SIG_MODE_NORMAL: case GPGME_SIG_MODE_DETACH: case GPGME_SIG_MODE_CLEAR: PHPC_THIS->signmode = signmode; RETVAL_TRUE; break; default: GNUPG_ERR("invalid signmode"); RETVAL_FALSE; break; } RETURN_TRUE; } /* }}} */ /* {{{ proto array gnupg_getengineinfo(void) * returns the engine info */ PHP_FUNCTION(gnupg_getengineinfo) { gpgme_engine_info_t info; GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } info = gpgme_ctx_get_engine_info(PHPC_THIS->ctx); PHPC_ARRAY_INIT(return_value); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "protocol", info->protocol); PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "file_name", info->file_name); PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "home_dir", info->home_dir ? info->home_dir : ""); } /* }}} */ /* {{{ proto string gnupg_geterror(void) * returns the last errormessage */ PHP_FUNCTION(gnupg_geterror) { GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHPC_THIS->errortxt) { RETURN_FALSE; } else { PHPC_CSTR_RETURN(PHPC_THIS->errortxt); } } /* }}} */ /* {{{ proto string gnupg_geterrorinfo(void) * returns the last error info array */ PHP_FUNCTION(gnupg_geterrorinfo) { GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } PHPC_ARRAY_INIT(return_value); if (PHPC_THIS->errortxt) { PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "generic_message", PHPC_THIS->errortxt); } else { PHPC_ARRAY_ADD_ASSOC_BOOL(return_value, "generic_message", 0); } PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "gpgme_code", PHPC_THIS->err); PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "gpgme_source", (char *) gpgme_strsource(PHPC_THIS->err)); PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "gpgme_message", (char *) gpgme_strerror(PHPC_THIS->err)); } /* }}} */ /* {{{ proto int gnupg_getprotocol(void) * returns the currently used pgp-protocol. * atm only OpenPGP is supported */ PHP_FUNCTION(gnupg_getprotocol) { RETURN_LONG(GPGME_PROTOCOL_OpenPGP); } /* }}} */ /* {{{ proto array gnupg_keyinfo(string pattern, bool secret_only = false) * returns an array with informations about all keys, that matches * the given pattern */ PHP_FUNCTION(gnupg_keyinfo) { char *searchkey = NULL; phpc_str_size_t searchkey_len; phpc_val subarr, userid, userids, subkey, subkeys; gpgme_key_t gpgme_key; gpgme_subkey_t gpgme_subkey; gpgme_user_id_t gpgme_userid; zend_bool secret_only = 0; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &searchkey, &searchkey_len, &secret_only) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|b", &res, &searchkey, &searchkey_len, &secret_only) == FAILURE) { return; } GNUPG_RES_FETCH(); } PHPC_THIS->err = gpgme_op_keylist_start(PHPC_THIS->ctx, searchkey, secret_only); if ((PHPC_THIS->err) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not init keylist"); return; } PHPC_ARRAY_INIT(return_value); while (PHP_GNUPG_DO(gpgme_op_keylist_next(PHPC_THIS->ctx, &gpgme_key))) { PHPC_VAL_MAKE(subarr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subarr)); PHPC_VAL_MAKE(subkeys); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subkeys)); PHPC_VAL_MAKE(userids); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(userids)); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subarr, disabled, gpgme_key); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subarr, expired, gpgme_key); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subarr, revoked, gpgme_key); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL_EX(subarr, is_secret, gpgme_key, secret); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subarr, can_sign, gpgme_key); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subarr, can_encrypt, gpgme_key); gpgme_userid = gpgme_key->uids; while (gpgme_userid) { PHPC_VAL_MAKE(userid); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(userid)); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(userid, name, gpgme_userid); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(userid, comment, gpgme_userid); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(userid, email, gpgme_userid); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(userid, uid, gpgme_userid); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(userid, revoked, gpgme_userid); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(userid, invalid, gpgme_userid); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL( PHPC_VAL_CAST_TO_PZVAL(userids), PHPC_VAL_CAST_TO_PZVAL(userid)); gpgme_userid = gpgme_userid->next; } PHPC_ARRAY_ADD_ASSOC_ZVAL( PHPC_VAL_CAST_TO_PZVAL(subarr), "uids", PHPC_VAL_CAST_TO_PZVAL(userids)); gpgme_subkey = gpgme_key->subkeys; while (gpgme_subkey) { PHPC_VAL_MAKE(subkey); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subkey)); if (gpgme_subkey->fpr) { PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR_EX(subkey, fingerprint, gpgme_subkey, fpr); } PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(subkey, keyid, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(subkey, timestamp, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(subkey, expires, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL_EX(subkey, is_secret, gpgme_subkey, secret); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, invalid, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, can_encrypt, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, can_sign, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, disabled, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, expired, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, revoked, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, can_certify, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, can_authenticate, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, is_qualified, gpgme_subkey); #if GPGME_VERSION_NUMBER >= 0x010900 /* GPGME >= 1.9.0 */ PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, is_de_vs, gpgme_subkey); #endif /* gpgme >= 1.9.0 */ /* https://github.com/gpg/gpgme/blob/f7700a016926f0d8e9cb3c0337837deb7fe01079/src/gpgme.h.in#L258 https://github.com/gpg/gpgme/blob/f7700a016926f0d8e9cb3c0337837deb7fe01079/src/gpgme.c#L1196 printf '0x%02x%02x%02x\n' 1 2 0 */ PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(subkey, pubkey_algo, gpgme_subkey); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(subkey, length, gpgme_subkey); #if GPGME_VERSION_NUMBER >= 0x010700 /* GPGME >= 1.7.0 */ if (gpgme_subkey->keygrip) { PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(subkey, keygrip, gpgme_subkey); } #endif /* gpgme >= 1.7.0 */ PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(subkey, is_cardkey, gpgme_subkey); if (gpgme_subkey->card_number) { PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(subkey, card_number, gpgme_subkey); } #if GPGME_VERSION_NUMBER >= 0x010500 /* GPGME >= 1.5.0 */ if (gpgme_subkey->curve) { PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(subkey, curve, gpgme_subkey); } #endif PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL( PHPC_VAL_CAST_TO_PZVAL(subkeys), PHPC_VAL_CAST_TO_PZVAL(subkey)); gpgme_subkey = gpgme_subkey->next; } PHPC_ARRAY_ADD_ASSOC_ZVAL( PHPC_VAL_CAST_TO_PZVAL(subarr), "subkeys", PHPC_VAL_CAST_TO_PZVAL(subkeys)); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL( return_value, PHPC_VAL_CAST_TO_PZVAL(subarr)); gpgme_key_unref(gpgme_key); } } /* }}} */ /* {{{ proto bool gnupg_addsignkey(string key) */ PHP_FUNCTION(gnupg_addsignkey) { char *key_id = NULL; phpc_str_size_t key_id_len; char *passphrase = NULL; phpc_str_size_t passphrase_len; gpgme_key_t gpgme_key; gpgme_subkey_t gpgme_subkey; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1))) { GNUPG_ERR("get_key failed"); return; } if (passphrase) { gpgme_subkey = gpgme_key->subkeys; while (gpgme_subkey) { if (gpgme_subkey->can_sign == 1) { PHPC_HASH_CSTR_ADD_PTR(PHPC_THIS->signkeys, gpgme_subkey->keyid, passphrase, passphrase_len + 1); } gpgme_subkey = gpgme_subkey->next; } } if (!PHP_GNUPG_DO(gpgme_signers_add(PHPC_THIS->ctx, gpgme_key))) { GNUPG_ERR("could not add signer"); } else { RETVAL_TRUE; } gpgme_key_unref(gpgme_key); } /* }}} */ /* {{{ proto bool gnupg_adddecryptkey(string key) */ PHP_FUNCTION(gnupg_adddecryptkey) { char *key_id = NULL; phpc_str_size_t key_id_len; char *passphrase = NULL; phpc_str_size_t passphrase_len; gpgme_key_t gpgme_key; gpgme_subkey_t gpgme_subkey; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1))) { GNUPG_ERR("get_key failed"); return; } gpgme_subkey = gpgme_key->subkeys; while (gpgme_subkey) { if (gpgme_subkey->secret == 1) { PHPC_HASH_CSTR_ADD_PTR( PHPC_THIS->decryptkeys, gpgme_subkey->keyid, passphrase, passphrase_len + 1); } gpgme_subkey = gpgme_subkey->next; } gpgme_key_unref(gpgme_key); RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_addencryptkey(string key) */ PHP_FUNCTION(gnupg_addencryptkey) { char *key_id = NULL; phpc_str_size_t key_id_len; gpgme_key_t gpgme_key = NULL; size_t encrypt_keys_size; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key_id, &key_id_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 0))) { GNUPG_ERR("get_key failed"); RETURN_FALSE; } encrypt_keys_size = sizeof(PHPC_THIS->encryptkeys) * (PHPC_THIS->encrypt_size + 2); if (PHPC_THIS->encryptkeys == NULL) { PHPC_THIS->encryptkeys = emalloc(encrypt_keys_size); } else { PHPC_THIS->encryptkeys = erealloc(PHPC_THIS->encryptkeys, encrypt_keys_size); } PHPC_THIS->encryptkeys[PHPC_THIS->encrypt_size] = gpgme_key; PHPC_THIS->encrypt_size++; PHPC_THIS->encryptkeys[PHPC_THIS->encrypt_size] = NULL; RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_clearsignerkeys(void) * removes all keys which are set for signing */ PHP_FUNCTION(gnupg_clearsignkeys) { GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } gpgme_signers_clear(PHPC_THIS->ctx); zend_hash_clean(PHPC_THIS->signkeys); RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_clearencryptkeys(void) * removes all keys which are set for encryption */ PHP_FUNCTION(gnupg_clearencryptkeys) { GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } php_gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC); RETURN_TRUE; } /* }}} */ /* {{{ proto bool gnupg_clearsignerkeys(void) * removes all keys which are set for signing */ PHP_FUNCTION(gnupg_cleardecryptkeys) { GNUPG_GETOBJ(); if (!this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { return; } GNUPG_RES_FETCH(); } zend_hash_clean(PHPC_THIS->decryptkeys); 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; phpc_str_size_t value_len; char *userret; size_t ret_size; gpgme_data_t in, out; gpgme_sign_result_t result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } gpgme_set_passphrase_cb(PHPC_THIS->ctx, passphrase_cb, PHPC_THIS); if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&in, value, value_len, 0))) { GNUPG_ERR("could not create in-data buffer"); return; } if (!PHP_GNUPG_DO(gpgme_data_new(&out))) { GNUPG_ERR("could not create out-data buffer"); gpgme_data_release(in); return; } if (!PHP_GNUPG_DO(gpgme_op_sign(PHPC_THIS->ctx, in, out, PHPC_THIS->signmode))) { if (!PHPC_THIS->errortxt) { GNUPG_ERR("data signing failed"); } gpgme_data_release(in); gpgme_data_release(out); RETVAL_FALSE; return; } result = gpgme_op_sign_result(PHPC_THIS->ctx); if (result->invalid_signers) { GNUPG_ERR("invalid signers found"); gpgme_data_release(in); gpgme_data_release(out); return; } if (!result->signatures) { GNUPG_ERR("no signature in result"); gpgme_data_release(in); gpgme_data_release(out); return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); if (ret_size < 1) { RETVAL_FALSE; } else { PHPC_CSTRL_RETVAL(userret, ret_size); } gpgme_data_release(in); free(userret); } /* }}} */ /* {{{ 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; phpc_str_size_t value_len; char *userret = NULL; size_t ret_size; gpgme_data_t in, out; gpgme_encrypt_result_t result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHPC_THIS->encryptkeys) { GNUPG_ERR("no key for encryption set"); return; } if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&in, value, value_len, 0))) { GNUPG_ERR("could no create in-data buffer"); return; } if (!PHP_GNUPG_DO(PHPC_THIS->err = gpgme_data_new(&out))) { GNUPG_ERR("could not create out-data buffer"); gpgme_data_release(in); return; } if (!PHP_GNUPG_DO(gpgme_op_encrypt(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))) { GNUPG_ERR("encrypt failed"); gpgme_data_release(in); gpgme_data_release(out); return; } result = gpgme_op_encrypt_result(PHPC_THIS->ctx); if (result->invalid_recipients) { GNUPG_ERR("Invalid recipient encountered"); gpgme_data_release(in); gpgme_data_release(out); return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); gpgme_data_release(in); PHPC_CSTRL_RETVAL(userret, ret_size); free(userret); if (ret_size < 1) { RETURN_FALSE; } } /* }}} */ /* {{{ proto string gnupg_encrypt_sign(string text) * encrypts and signs the given text with the keys, which weres set * with setencryptkey and setsignkey before, and returns the encrypted text */ PHP_FUNCTION(gnupg_encryptsign) { char *value = NULL; phpc_str_size_t value_len; char *userret = NULL; size_t ret_size; gpgme_data_t in, out; gpgme_encrypt_result_t result; gpgme_sign_result_t sign_result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHPC_THIS->encryptkeys) { GNUPG_ERR("no key for encryption set"); return; } gpgme_set_passphrase_cb(PHPC_THIS->ctx, passphrase_cb, PHPC_THIS); if (!PHP_GNUPG_DO(gpgme_data_new_from_mem (&in, value, value_len, 0))) { GNUPG_ERR("could not create in-data buffer"); return; } if (!PHP_GNUPG_DO(gpgme_data_new(&out))) { GNUPG_ERR("could not create out-data buffer"); gpgme_data_release(in); return; } if (!PHP_GNUPG_DO(gpgme_op_encrypt_sign(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))) { if (!PHPC_THIS->errortxt) { GNUPG_ERR("encrypt-sign failed"); } gpgme_data_release(in); gpgme_data_release(out); RETVAL_FALSE; return; } result = gpgme_op_encrypt_result (PHPC_THIS->ctx); if (result->invalid_recipients) { GNUPG_ERR("Invalid recipient encountered"); gpgme_data_release(in); gpgme_data_release(out); return; } sign_result = gpgme_op_sign_result (PHPC_THIS->ctx); if (sign_result->invalid_signers) { GNUPG_ERR("invalid signers found"); gpgme_data_release(in); gpgme_data_release(out); return; } if (!sign_result->signatures) { GNUPG_ERR("could not find a signature"); gpgme_data_release(in); gpgme_data_release(out); return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); gpgme_data_release(in); PHPC_CSTRL_RETVAL(userret, ret_size); free (userret); if (ret_size < 1) { RETURN_FALSE; } } /* }}} */ /* {{{ proto array gnupg_verify(string text, string signature [, string &plaintext]) * verifies the given clearsigned text and returns information about the result in an array */ PHP_FUNCTION(gnupg_verify) { gpgme_data_t gpgme_text, gpgme_sig; gpgme_verify_result_t gpgme_result; /* text without the signature, if its a detached one, or the text incl the sig */ zval *signed_text = NULL; /* signature, if its a detached one */ zval *signature = NULL; /* signed_text without the signature if its not a detached sig */ zval *plain_text = NULL; char *gpg_plain; size_t gpg_plain_len; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &signed_text, &signature, &plain_text) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (Z_TYPE_P(signature) == IS_STRING) { /* detached signature */ /* setup signature-databuffer for gpgme */ if (!PHP_GNUPG_DO(gpgme_data_new_from_mem( &gpgme_sig, Z_STRVAL_P(signature), Z_STRLEN_P(signature), 0))) { GNUPG_ERR("could not create signature-databuffer"); return; } /* and the text */ if (!PHP_GNUPG_DO(gpgme_data_new_from_mem( &gpgme_text, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))) { GNUPG_ERR("could not create text-databuffer"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } /* now verify sig + text */ if (!PHP_GNUPG_DO(gpgme_op_verify(PHPC_THIS->ctx, gpgme_sig, gpgme_text, NULL))) { GNUPG_ERR("verify failed"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } } else { /* clearsign or normal signature */ if (!PHP_GNUPG_DO(gpgme_data_new_from_mem( &gpgme_sig, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))) { GNUPG_ERR("could not create signature-databuffer"); return; } /* set a NULL databuffer for gpgme */ if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&gpgme_text, NULL, 0, 0))) { GNUPG_ERR("could not create text-databuffer"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } /* and verify the 'signature' */ if (!PHP_GNUPG_DO(gpgme_op_verify(PHPC_THIS->ctx, gpgme_sig, NULL, gpgme_text))) { GNUPG_ERR("verify failed"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } } /* now get the result */ gpgme_result = gpgme_op_verify_result(PHPC_THIS->ctx); if (!gpgme_result->signatures) { GNUPG_ERR("no signature found"); } else { /* fetch all signatures in an array */ gnupg_fetchsignatures(gpgme_result->signatures, return_value); /* get a 'plain' version of the text without a signature */ gpg_plain = gpgme_data_release_and_get_mem(gpgme_text, &gpg_plain_len); if (gpg_plain && gpg_plain_len > 0 && plain_text) { PHPC_PZVAL_DEREF(plain_text); PHPC_PZVAL_CSTRL(plain_text, gpg_plain, gpg_plain_len); } free(gpg_plain); } gpgme_data_release(gpgme_sig); } /* }}} */ /* {{{ proto string gnupg_decrypt(string enctext) * decrypts the given enctext */ PHP_FUNCTION(gnupg_decrypt) { char *enctxt; phpc_str_size_t enctxt_len; char *userret; size_t ret_size; gpgme_data_t in, out; gpgme_decrypt_result_t result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &enctxt, &enctxt_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } gpgme_set_passphrase_cb(PHPC_THIS->ctx, passphrase_decrypt_cb, PHPC_THIS); if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&in, enctxt, enctxt_len, 0))) { GNUPG_ERR("could not create in-data buffer"); } if ((PHPC_THIS->err = gpgme_data_new(&out)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create out-data buffer"); gpgme_data_release(in); return; } if (!PHP_GNUPG_DO(gpgme_op_decrypt(PHPC_THIS->ctx, in, out))) { if (!PHPC_THIS->errortxt) { GNUPG_ERR("decrypt failed"); } gpgme_data_release(in); gpgme_data_release(out); RETVAL_FALSE; return; } result = gpgme_op_decrypt_result(PHPC_THIS->ctx); if (result->unsupported_algorithm) { GNUPG_ERR("unsupported algorithm"); gpgme_data_release(in); gpgme_data_release(out); return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); gpgme_data_release(in); PHPC_CSTRL_RETVAL(userret, ret_size); free(userret); if (ret_size < 1) { RETVAL_FALSE; } } /* }}} */ /* {{{ proto string gnupg_decryptverify(string enctext, string &plaintext) * decrypts the given enctext */ PHP_FUNCTION(gnupg_decryptverify) { char *enctxt; phpc_str_size_t enctxt_len; zval *plaintext; char *userret; size_t ret_size; gpgme_data_t in, out; gpgme_decrypt_result_t decrypt_result; gpgme_verify_result_t verify_result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &enctxt, &enctxt_len, &plaintext) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE) { return; } GNUPG_RES_FETCH(); } PHPC_PZVAL_DEREF(plaintext); gpgme_set_passphrase_cb(PHPC_THIS->ctx, passphrase_decrypt_cb, PHPC_THIS); if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&in, enctxt, enctxt_len, 0))) { GNUPG_ERR("could not create in-data buffer"); } if (!PHP_GNUPG_DO(gpgme_data_new(&out))) { GNUPG_ERR("could not create out-data buffer"); gpgme_data_release(in); return; } if (!PHP_GNUPG_DO(gpgme_op_decrypt_verify(PHPC_THIS->ctx, in, out))) { if (!PHPC_THIS->errortxt) { GNUPG_ERR("decrypt-verify failed"); } gpgme_data_release(in); gpgme_data_release(out); RETVAL_FALSE; return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); PHPC_PZVAL_CSTRL(plaintext, userret, ret_size); free(userret); decrypt_result = gpgme_op_decrypt_result(PHPC_THIS->ctx); if (decrypt_result->unsupported_algorithm) { GNUPG_ERR("unsupported algorithm"); gpgme_data_release(in); return; } verify_result = gpgme_op_verify_result(PHPC_THIS->ctx); if (!verify_result->signatures) { GNUPG_ERR("no signature found"); gpgme_data_release(in); return; } gnupg_fetchsignatures(verify_result->signatures, return_value); gpgme_data_release(in); } /* }}} */ /* {{{ proto string gnupg_export(string pattern) * exports the first public key which matches against the given pattern */ PHP_FUNCTION(gnupg_export) { char *searchkey = NULL; phpc_str_size_t searchkey_len; char *userret; size_t ret_size; gpgme_data_t out; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &searchkey, &searchkey_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_data_new(&out))) { GNUPG_ERR("could not create data buffer"); return; } if (!PHP_GNUPG_DO(gpgme_op_export(PHPC_THIS->ctx, searchkey, 0, out))) { GNUPG_ERR("export failed"); gpgme_data_release(out); return; } userret = gpgme_data_release_and_get_mem(out, &ret_size); if (ret_size < 1) { RETVAL_FALSE; } else { PHPC_CSTRL_RETVAL(userret, ret_size); } free(userret); } /* }}} */ /* {{{ proto array gnupg_import(string key) * imports the given key and returns a status-array */ PHP_FUNCTION(gnupg_import) { char *importkey = NULL; phpc_str_size_t importkey_len; gpgme_data_t in; gpgme_import_result_t result; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &importkey, &importkey_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_data_new_from_mem(&in, importkey, importkey_len, 0))) { GNUPG_ERR("could not create in-data buffer"); return; } if (!PHP_GNUPG_DO(gpgme_op_import(PHPC_THIS->ctx, in))) { GNUPG_ERR("import failed"); gpgme_data_release(in); return; } gpgme_data_release(in); result = gpgme_op_import_result(PHPC_THIS->ctx); if (!result || !result->imports || result->imports->result != GPG_ERR_NO_ERROR) { RETURN_FALSE; } PHPC_ARRAY_INIT(return_value); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "imported", result->imported); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "unchanged", result->unchanged); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "newuserids", result->new_user_ids); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "newsubkeys", result->new_sub_keys); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "secretimported", result->secret_imported); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "secretunchanged", result->secret_unchanged); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "newsignatures", result->new_signatures); PHPC_ARRAY_ADD_ASSOC_LONG(return_value, "skippedkeys", result->skipped_new_keys); if (result->imports && result->imports->fpr) { PHPC_ARRAY_ADD_ASSOC_CSTR(return_value, "fingerprint", result->imports->fpr); } } /* }}} */ #ifndef GPGME_DELETE_ALLOW_SECRET #define GPGME_DELETE_ALLOW_SECRET 1 #endif /* {{{ proto book gnupg_deletekey(string key) * deletes a key from the keyring */ PHP_FUNCTION(gnupg_deletekey) { char *key; phpc_str_size_t key_len; zend_bool allow_secret = 0; gpgme_key_t gpgme_key; unsigned int flags = 0; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &key, &key_len, &allow_secret) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|b", &res, &key, &key_len, &allow_secret) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_get_key(PHPC_THIS->ctx, key, &gpgme_key, 0))) { GNUPG_ERR("get_key failed"); return; } if (allow_secret) { flags = GPGME_DELETE_ALLOW_SECRET; } if (!PHP_GNUPG_DO(gpgme_op_delete(PHPC_THIS->ctx, gpgme_key, flags))) { GNUPG_ERR("delete failed"); RETVAL_FALSE; } else { RETVAL_TRUE; } gpgme_key_unref(gpgme_key); } /* }}} */ /* {{{ proto array gnupg_gettrustlist(string pattern) * searching for trust items which match PATTERN */ PHP_FUNCTION(gnupg_gettrustlist) { char *pattern; phpc_str_size_t pattern_len; phpc_val sub_arr; gpgme_trust_item_t item; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &pattern, &pattern_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_op_trustlist_start(PHPC_THIS->ctx, pattern, 0))) { GNUPG_ERR("could not start trustlist"); return; } PHPC_ARRAY_INIT(return_value); while (PHP_GNUPG_DO(gpgme_op_trustlist_next(PHPC_THIS->ctx, &item))) { PHPC_VAL_MAKE(sub_arr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(sub_arr)); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sub_arr, level, item); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sub_arr, type, item); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sub_arr, keyid, item); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR_EX(sub_arr, ownertrust, item, owner_trust); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sub_arr, validity, item); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sub_arr, name, item); gpgme_trust_item_unref(item); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(return_value, PHPC_VAL_CAST_TO_PZVAL(sub_arr)); } } /* }}} */ /* {{{ proto array gnupg_listsignatures(string keyid) */ PHP_FUNCTION(gnupg_listsignatures) { char *keyid; phpc_str_size_t keyid_len; phpc_val sub_arr; phpc_val sig_arr; gpgme_key_t gpgme_key; gpgme_user_id_t gpgme_userid; gpgme_key_sig_t gpgme_signature; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &keyid, &keyid_len) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE) { return; } GNUPG_RES_FETCH(); } if (!PHP_GNUPG_DO(gpgme_set_keylist_mode(PHPC_THIS->ctx, GPGME_KEYLIST_MODE_SIGS))) { GNUPG_ERR("could not switch to sigmode"); return; } if (!PHP_GNUPG_DO(gpgme_get_key(PHPC_THIS->ctx, keyid, &gpgme_key, 0))) { GNUPG_ERR("get_key failed. given key not unique?"); return; } if (!gpgme_key->uids) { GNUPG_ERR("no uids found"); gpgme_key_unref(gpgme_key); return; } PHPC_ARRAY_INIT(return_value); gpgme_userid = gpgme_key->uids; while (gpgme_userid) { PHPC_VAL_MAKE(sub_arr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(sub_arr)); gpgme_signature = gpgme_userid->signatures; while (gpgme_signature) { PHPC_VAL_MAKE(sig_arr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(sig_arr)); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sig_arr, uid, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sig_arr, name, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sig_arr, email, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_CSTR(sig_arr, comment, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, expires, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(sig_arr, revoked, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(sig_arr, expired, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_BOOL(sig_arr, invalid, gpgme_signature); PHP_GNUPG_ARRAY_ADD_ASSOC_LONG(sig_arr, timestamp, gpgme_signature); PHPC_ARRAY_ADD_ASSOC_ZVAL( PHPC_VAL_CAST_TO_PZVAL(sub_arr), gpgme_signature->keyid, PHPC_VAL_CAST_TO_PZVAL(sig_arr) ); gpgme_signature = gpgme_signature->next; } PHPC_ARRAY_ADD_ASSOC_ZVAL( return_value, gpgme_userid->uid, PHPC_VAL_CAST_TO_PZVAL(sub_arr)); gpgme_userid = gpgme_userid->next; } gpgme_key_unref(gpgme_key); } /* }}} */ /* * 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 */ gnupg-1.5.1/gnupg_keylistiterator.c0000664000175000017500000001425714163677356016447 0ustar jakubjakub/* +--------------------------------------------------------------------+ | PECL :: gnupg | +--------------------------------------------------------------------+ | Redistribution and use in source and binary forms, with or without | | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ | Copyright (c) 2006, Thilo Raufeisen | | Copyright (c) 2013, Jim Jagielski | | Copyright (c) 2016, Jakub Zelenka | +--------------------------------------------------------------------+ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" #include "zend_interfaces.h" #include "zend_exceptions.h" #include "php_gnupg.h" #include "php_gnupg_keylistiterator.h" #include "phpc/phpc.h" static int le_gnupg_keylistiterator; static zend_class_entry *gnupg_keylistiterator_class_entry; PHPC_OBJ_DEFINE_HANDLER_VAR(gnupg_keylistiterator); /* {{{ GNUPG_GET_ITERATOR */ #define GNUPG_GET_ITERATOR() \ zval *this = getThis(); \ PHPC_THIS_DECLARE(gnupg_keylistiterator) = NULL; \ do { \ if (this) { \ PHPC_THIS_FETCH_FROM_ZVAL(gnupg_keylistiterator, this); \ if (!PHPC_THIS) { \ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \ RETURN_FALSE; \ } \ } \ } while (0) /* }}} */ /* {{{ free gnupg_keylistiterator */ PHPC_OBJ_HANDLER_FREE(gnupg_keylistiterator) { PHPC_OBJ_HANDLER_FREE_INIT(gnupg_keylistiterator); gpgme_op_keylist_end(PHPC_THIS->ctx); gpgme_key_release(PHPC_THIS->gpgkey); gpgme_release(PHPC_THIS->ctx); if (PHPC_THIS->pattern) { efree(PHPC_THIS->pattern); } PHPC_OBJ_HANDLER_FREE_DESTROY(); } /* {{{ create_ex gnupg_keylistiterator */ PHPC_OBJ_HANDLER_CREATE_EX(gnupg_keylistiterator) { PHPC_OBJ_HANDLER_CREATE_EX_INIT(gnupg_keylistiterator); gpgme_check_version(NULL); gpgme_new(&PHPC_THIS->ctx); PHPC_THIS->err = 0; PHPC_THIS->gpgkey = NULL; PHPC_THIS->pattern = NULL; PHPC_OBJ_HANDLER_CREATE_EX_RETURN(gnupg_keylistiterator); } /* {{{ create gnupg_keylistiterator */ PHPC_OBJ_HANDLER_CREATE(gnupg_keylistiterator) { PHPC_OBJ_HANDLER_CREATE_RETURN(gnupg_keylistiterator); } /* {{{ arginfo for gnupg void iterator method */ ZEND_BEGIN_ARG_INFO_EX(arginfo_gnupg_void_iterator_method, 0, 0, 0) ZEND_END_ARG_INFO() /* }}} */ ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_gnupg_current, 0, 0, IS_MIXED, 0) ZEND_END_ARG_INFO() #define arginfo_gnupg_key arginfo_gnupg_current ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_gnupg_valid, 0, 0, _IS_BOOL, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_gnupg_next, 0, 0, IS_VOID, 0) ZEND_END_ARG_INFO() #define arginfo_gnupg_rewind arginfo_gnupg_next /* {{{ method list gnupg_keylistiterator */ static zend_function_entry gnupg_keylistiterator_methods[] = { PHP_ME(gnupg_keylistiterator, __construct, arginfo_gnupg_void_iterator_method, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, current, arginfo_gnupg_current, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, key, arginfo_gnupg_key, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, next, arginfo_gnupg_next, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, rewind, arginfo_gnupg_rewind, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, valid, arginfo_gnupg_valid, ZEND_ACC_PUBLIC) PHPC_FE_END }; /* }}} */ /* {{{ _gnupg_keylistiterator_init */ int _gnupg_keylistiterator_init(INIT_FUNC_ARGS) { zend_class_entry ce; /* init class */ INIT_CLASS_ENTRY(ce, "gnupg_keylistiterator", gnupg_keylistiterator_methods); PHPC_CLASS_SET_HANDLER_CREATE(ce, gnupg_keylistiterator); gnupg_keylistiterator_class_entry = PHPC_CLASS_REGISTER(ce); PHPC_OBJ_INIT_HANDLERS(gnupg_keylistiterator); PHPC_OBJ_SET_HANDLER_OFFSET(gnupg_keylistiterator); PHPC_OBJ_SET_HANDLER_FREE(gnupg_keylistiterator); zend_class_implements(gnupg_keylistiterator_class_entry TSRMLS_CC, 1, zend_ce_iterator); le_gnupg_keylistiterator = zend_register_list_destructors_ex(NULL, NULL, "ctx_keylistiterator", module_number); return SUCCESS; } /* }}} */ /* {{{ proto __contruct(string $pattern) * constructs keylistiterator with supplied pattern */ PHP_METHOD(gnupg_keylistiterator, __construct) { char *pattern = NULL; phpc_str_size_t pattern_len; int args = ZEND_NUM_ARGS(); GNUPG_GET_ITERATOR(); if (args > 0) { if (zend_parse_parameters(args TSRMLS_CC, "|s", &pattern, &pattern_len) == FAILURE) { return; } PHPC_THIS->pattern = estrdup(pattern); } } /* }}} */ /* {{{ proto string current() */ PHP_METHOD(gnupg_keylistiterator, current) { GNUPG_GET_ITERATOR(); PHPC_CSTR_RETURN(PHPC_THIS->gpgkey->uids[0].uid); } /* }}} */ /* {{{ proto string key() */ PHP_METHOD(gnupg_keylistiterator, key) { GNUPG_GET_ITERATOR(); PHPC_CSTR_RETURN(PHPC_THIS->gpgkey->subkeys[0].fpr); } /* }}} */ /* {{{ proto bool next() */ PHP_METHOD(gnupg_keylistiterator, next) { GNUPG_GET_ITERATOR(); if (PHPC_THIS->gpgkey){ gpgme_key_release(PHPC_THIS->gpgkey); } if ((PHPC_THIS->err = gpgme_op_keylist_next(PHPC_THIS->ctx, &PHPC_THIS->gpgkey))) { gpgme_key_release(PHPC_THIS->gpgkey); PHPC_THIS->gpgkey = NULL; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool rewind() */ PHP_METHOD(gnupg_keylistiterator, rewind) { GNUPG_GET_ITERATOR(); if ((PHPC_THIS->err = gpgme_op_keylist_start( PHPC_THIS->ctx, PHPC_THIS->pattern ? PHPC_THIS->pattern : "", 0)) != GPG_ERR_NO_ERROR){ zend_throw_exception(zend_exception_get_default(TSRMLS_C), (char *)gpg_strerror(PHPC_THIS->err), 1 TSRMLS_CC); } if ((PHPC_THIS->err = gpgme_op_keylist_next(PHPC_THIS->ctx, &PHPC_THIS->gpgkey)) != GPG_ERR_NO_ERROR){ RETURN_FALSE; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool valid() */ PHP_METHOD(gnupg_keylistiterator,valid) { GNUPG_GET_ITERATOR(); if (PHPC_THIS->gpgkey != NULL) { RETURN_TRUE; } else { RETURN_FALSE; } } /* }}} */ /* * 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 */ gnupg-1.5.1/LICENSE0000664000175000017500000000747114163677356012652 0ustar jakubjakubCopyright (c) 2005, Thilo Raufeisen . All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 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. ---- Copyright (c) 2013, Jim Jagielski . Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 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. ---- Copyright (c) 2016, Jakub Zelenka . Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 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. gnupg-1.5.1/php_gnupg_keylistiterator.h0000664000175000017500000000365014163677356017316 0ustar jakubjakub/* +--------------------------------------------------------------------+ | PECL :: gnupg | +--------------------------------------------------------------------+ | Redistribution and use in source and binary forms, with or without | | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ | Copyright (c) 2006, Thilo Raufeisen | | Copyright (c) 2013, Jim Jagielski | | Copyright (c) 2016, Jakub Zelenka | +--------------------------------------------------------------------+ */ #ifndef PHP_GNUPG_KEYLISTITERATOR_H #define PHP_GNUPG_KEYLISTITERATOR_H extern zend_module_entry gnupg_keyiterator_module_entry; #ifdef PHP_WIN32 #define PHP_GNUPG_API __declspec(dllexport) #else #define PHP_GNUPG_API #endif #ifdef ZTS #include "TSRM.h" #endif #include #include "phpc/phpc.h" #define gnupg_keylistiterator_init() _gnupg_keylistiterator_init(INIT_FUNC_ARGS_PASSTHRU) extern int _gnupg_keylistiterator_init(INIT_FUNC_ARGS); PHPC_OBJ_STRUCT_BEGIN(gnupg_keylistiterator) gpgme_ctx_t ctx; gpgme_error_t err; gpgme_key_t gpgkey; char *pattern; PHPC_OBJ_STRUCT_END() PHP_METHOD(gnupg_keylistiterator, __construct); PHP_METHOD(gnupg_keylistiterator, current); PHP_METHOD(gnupg_keylistiterator, next); PHP_METHOD(gnupg_keylistiterator, rewind); PHP_METHOD(gnupg_keylistiterator, key); PHP_METHOD(gnupg_keylistiterator, valid); #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 */ gnupg-1.5.1/php_gnupg.h0000664000175000017500000000512014163677356013772 0ustar jakubjakub/* +--------------------------------------------------------------------+ | PECL :: gnupg | +--------------------------------------------------------------------+ | Redistribution and use in source and binary forms, with or without | | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ | Copyright (c) 2006, Thilo Raufeisen | | Copyright (c) 2013, Jim Jagielski | | Copyright (c) 2016, Jakub Zelenka | +--------------------------------------------------------------------+ */ #ifndef PHP_GNUPG_H #define PHP_GNUPG_H extern zend_module_entry gnupg_module_entry; #define phpext_gnupg_ptr &gnupg_module_entry #define PHP_GNUPG_VERSION "1.5.1" #ifdef PHP_WIN32 #define PHP_GNUPG_API __declspec(dllexport) #else #define PHP_GNUPG_API #endif #ifdef ZTS #include "TSRM.h" #endif #include #include "phpc/phpc.h" PHPC_OBJ_STRUCT_BEGIN(gnupg) gpgme_ctx_t ctx; gpgme_error_t err; int errormode; char* errortxt; int signmode; gpgme_key_t *encryptkeys; unsigned int encrypt_size; HashTable *signkeys; HashTable *decryptkeys; PHPC_OBJ_STRUCT_END() PHP_MINIT_FUNCTION(gnupg); PHP_MSHUTDOWN_FUNCTION(gnupg); PHP_MINFO_FUNCTION(gnupg); PHP_METHOD(gnupg, __construct); PHP_FUNCTION(gnupg_keyinfo); PHP_FUNCTION(gnupg_verify); PHP_FUNCTION(gnupg_getengineinfo); PHP_FUNCTION(gnupg_geterror); PHP_FUNCTION(gnupg_geterrorinfo); PHP_FUNCTION(gnupg_setsignmode); PHP_FUNCTION(gnupg_setarmor); PHP_FUNCTION(gnupg_sign); PHP_FUNCTION(gnupg_clearsignkeys); PHP_FUNCTION(gnupg_clearencryptkeys); PHP_FUNCTION(gnupg_cleardecryptkeys); PHP_FUNCTION(gnupg_getprotocol); PHP_FUNCTION(gnupg_encrypt); PHP_FUNCTION(gnupg_encryptsign); PHP_FUNCTION(gnupg_decrypt); PHP_FUNCTION(gnupg_decryptverify); PHP_FUNCTION(gnupg_export); PHP_FUNCTION(gnupg_import); PHP_FUNCTION(gnupg_init); PHP_FUNCTION(gnupg_addsignkey); PHP_FUNCTION(gnupg_addencryptkey); PHP_FUNCTION(gnupg_adddecryptkey); PHP_FUNCTION(gnupg_deletekey); PHP_FUNCTION(gnupg_gettrustlist); PHP_FUNCTION(gnupg_listsignatures); PHP_FUNCTION(gnupg_seterrormode); #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 */ gnupg-1.5.1/php_gnupg_keylistiterator.h0000664000175000017500000000365014163677356017316 0ustar jakubjakub/* +--------------------------------------------------------------------+ | PECL :: gnupg | +--------------------------------------------------------------------+ | Redistribution and use in source and binary forms, with or without | | modification, are permitted provided that the conditions mentioned | | in the accompanying LICENSE file are met. | +--------------------------------------------------------------------+ | Copyright (c) 2006, Thilo Raufeisen | | Copyright (c) 2013, Jim Jagielski | | Copyright (c) 2016, Jakub Zelenka | +--------------------------------------------------------------------+ */ #ifndef PHP_GNUPG_KEYLISTITERATOR_H #define PHP_GNUPG_KEYLISTITERATOR_H extern zend_module_entry gnupg_keyiterator_module_entry; #ifdef PHP_WIN32 #define PHP_GNUPG_API __declspec(dllexport) #else #define PHP_GNUPG_API #endif #ifdef ZTS #include "TSRM.h" #endif #include #include "phpc/phpc.h" #define gnupg_keylistiterator_init() _gnupg_keylistiterator_init(INIT_FUNC_ARGS_PASSTHRU) extern int _gnupg_keylistiterator_init(INIT_FUNC_ARGS); PHPC_OBJ_STRUCT_BEGIN(gnupg_keylistiterator) gpgme_ctx_t ctx; gpgme_error_t err; gpgme_key_t gpgkey; char *pattern; PHPC_OBJ_STRUCT_END() PHP_METHOD(gnupg_keylistiterator, __construct); PHP_METHOD(gnupg_keylistiterator, current); PHP_METHOD(gnupg_keylistiterator, next); PHP_METHOD(gnupg_keylistiterator, rewind); PHP_METHOD(gnupg_keylistiterator, key); PHP_METHOD(gnupg_keylistiterator, valid); #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 */ gnupg-1.5.1/README.md0000664000175000017500000000261414163677356013116 0ustar jakubjakub# PHP GnuPG The php-gnupg is a wrapper for GpgME library that provides access to GnuPG. ## Installation ### Linux Before starting with installation of this extensions, the `GpgME` library has to be installed. It has got installation packages on the most Linux distributions. The minimal version of GpgME that is supported is 1.3.0. The extension supports GnuPG version 1 and 2. Of course PHP has to be installed too. The minimal version that is supported is 5.3.2. #### PECL This extension is available on PECL. ``` $ sudo pecl install gnupg ``` #### Manual Installation It's important to have a git installed as it's necessary for recursive fetch of [phpc](https://github.com/bukka/phpc). First clone recursively the repository ``` git clone --recursive https://github.com/php-gnupg/php-gnupg.git ``` Then go to the created directory and compile the extension. The PHP development package has to be installed (command `phpize` must be available). ``` cd php-gnupg phpize ./configure make sudo make install ``` Finally the following line needs to be added to `php.ini` ``` extension=gnupg.so ``` or for PHP 8+ it's just ``` extension=gnupg ``` ### Windows The extension is not currently supported on Windows due to unavailable GpgME library builds that would be supported by PHP. ## Documentation The extension documentation is now available in the PHP-Manual: http://php.net/manual/en/book.gnupg.php gnupg-1.5.1/UPGRADING.md0000664000175000017500000000054414163677356013501 0ustar jakubjakub# PHP GnuPG Upgrading notes This document lists backward incompatible change in the extension ## 1.5.0 - no backward incompatible changes ## 1.4.0 - gnupg_decryptverify $plaintext reference can no longer be passed in call_user_func_array which is conformant to user space code. See https://github.com/php-gnupg/php-gnupg/issues/4 for more details.