package.xml0000664000175000017500000002747512761103325012166 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 yes Sean DuBois seander sean@siobud.com yes 2016-08-29 1.4.0 1.4.0 stable stable BSD, revised * No changes since 1.4.0RC2 5.2.0 1.4.0b1 gnupg 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.4.0/phpc/phpc.h0000664000175000017500000015345512761103324013661 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)) #define PHPC_CLASS_SET_HANDLER_CREATE(_class_entry, _name) \ _class_entry.create_object = PHPC_OBJ_GET_HANDLER_FCE(_name, create) #define PHPC_OBJ_SET_HANDLER_CLONE(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).clone_obj = PHPC_OBJ_GET_HANDLER_FCE(_name, clone) #define PHPC_OBJ_SET_HANDLER_COMPARE(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).compare_objects = 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 #if PHP_VERSION_ID < 50299 #define phpc_function_entry zend_function_entry #else #define phpc_function_entry const zend_function_entry #endif /* initializing properties in obejct (object_properties_init was added in PHP 5.4) */ #if PHP_VERSION_ID < 50399 #define PHPC_OBJ_PROPERTIES_INIT(zo, class_type) \ { \ zval *tmp; \ zend_hash_copy((*(zo)).properties, \ &(class_type)->default_properties, \ (copy_ctor_func_t) zval_add_ref, \ (void *) &tmp, \ sizeof(zval *)); \ } #else #define PHPC_OBJ_PROPERTIES_INIT object_properties_init #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 == 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_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) /* 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)) /* 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_SELF(_name) \ PHPC_OBJ_FROM_ZVAL(_name, PHPC_SELF) #define PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) \ PHPC_OBJ_FROM_ZOBJ(_name, _phpc_object) /* 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)(zval *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_HANDLER_OFFSET(_name) PHPC_NOOP #define PHPC_OBJ_SET_HANDLER_FREE(_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_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) /* 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 *)) /* 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)) != 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) /* 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_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_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_PVAL_DEREF(_pv) PHPC_NOOP #define PHPC_PZVAL_DEREF(_pv) PHPC_NOOP #define PHPC_VAL_STR(_pv, _str) \ ZVAL_STRINGL(_pv, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) #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_STR PHPC_VAL_STR #define PHPC_PZVAL_CSTR PHPC_VAL_CSTR #define PHPC_PZVAL_CSTRL PHPC_VAL_CSTRL #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 /* 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 /* 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)) /* 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)) #define PHPC_OBJ_FROM_SELF(_name) \ PHPC_OBJ_FROM_ZVAL(_name, PHPC_SELF) #define PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) \ PHPC_OBJ_FROM_ZOBJ(_name, _phpc_object) /* 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)(zval *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_HANDLER_OFFSET(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).offset = XtOffsetOf(PHPC_OBJ_STRUCT_NAME(_name), std) #define PHPC_OBJ_SET_HANDLER_FREE(_name) \ PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).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, _object, _name, _name_len, _silent, &PHPC_READ_PROPERTY_RV_NAME) /* HASH */ /* apply count */ #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 /* 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) /* 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 /* 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_OBJCE Z_OBJCE #define PHPC_OBJCE_P Z_OBJCE_P #define PHPC_OBJPROP Z_OBJPROP #define PHPC_OBJPROP_P Z_OBJPROP_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_PVAL_DEREF ZVAL_DEREF #define PHPC_PZVAL_DEREF ZVAL_DEREF #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_STR ZVAL_STR #define PHPC_PZVAL_CSTR ZVAL_STRING #define PHPC_PZVAL_CSTRL ZVAL_STRINGL #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 PHPC_OBJ_STRUCT_DECLARE_AND_FETCH_FROM_ZOBJ(_name, _ptr) \ PHPC_OBJ_STRUCT_DECLARE(_name, _ptr) = PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) /* 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_ZVAL(_name, PHPC_SELF) #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)\ (zval *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)\ (zval *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)\ (zval *PHPC_SELF TSRMLS_DC) /* 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 #endif /* PHPC_H */ gnupg-1.4.0/tests/gnupg_oo_0001_import.phpt0000664000175000017500000000127612761103324017523 0ustar jakubjakub--TEST--n 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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" } gnupg-1.4.0/tests/gnupg_oo_encrypt.phpt0000664000175000017500000000071412761103324017231 0ustar jakubjakub--TEST-- encrypt and decrypt a text --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $gpg -> addencryptkey($fingerprint); $enc = $gpg -> encrypt($plaintext); $gpg = NULL; $gpg = new gnupg(); $gpg -> adddecryptkey($fingerprint, $passphrase); $ret = $gpg -> decrypt ($enc); var_dump($ret); ?> --EXPECTF-- string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_encryptsign.phpt0000664000175000017500000000146312761103324020114 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); $gpg = NULL; $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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_export.phpt0000664000175000017500000000313212761103324017063 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----- Version: GnuPG v1.%d.%d (GNU/Linux) mQGiBENQAKwRBADpy828KU+0SuoetJTrJ5dR86PiO3CsH8K6QRP7wY82Eh/9NTJ3 afRj0FNPaVSP0NciPeM4G4uFoQ3lsIf+FBEPXH1D97/XigWObU8K6ha2/s8wU98z /samjTHLR+VKZ031B5/8p5Y49yvkkEyBkF1G85yeIXK0WZorKBPncRKuUwCgxOi/ IEa+ZuqHlmlDF2LTRIBOfrkEAK+WLRMWUD0bqj1TYwnxwPWiuns32/ZXLWuPfb5o crNt7x5LSe7wJhjyIiFhiU0qR33X/FrT2umzOxlRYfINXT9DUHDocxxbED6fxAHw X2IDd5tWXgCkSBHn2yAneNY6ycPdS3RvqJGlYFg7cOc0kz4urjqRt9fIagzpZQtL fXHfBACl3EWgvLhVBo5ExZbrtlOA2q0x9UGhhNaSkeBWBr2qDeZErQjMTO0+viaN /SX0zxeWtM3z06rkUHd1DKORDRM5R7shBTv9/Quojn0gbYbOem+e1mlCe27TRxcP yeIKk00PqbVuff9QlK9GqKEWGzsEXCmxZ160Dul3CGlf/vQZHbQkdGVzdGtleSAo dGVzdGtleSkgPHRlc3RAZXhhbXBsZS5uZXQ+iF4EExECAB4FAkNQAKwCGwMGCwkI BwMCAxUCAwMWAgECHgECF4AACgkQLpbxQbPdKy58pwCcDz9qEBEVt1gcKCwNay0f m4vLqCkAn1P0KV1giECUVXBuZ5YUndDB1QqtuQENBENQAK0QBACNXzJQG4NHUJqL PImezbl+ii+93MjMo8LpSlv9Np5ruWIKtxuqmVEe4k+r1DDmSl8hppifpRtx2hef bDTl8Tdf5MNGvf5JE3AHYUehZ+ldjgYCOZ53fJDgKV65ZidQSGGXsRcyE7SHgMQ6 rTL92PA2IQmkcf9xkg6xM2h55UusMwADBQP9EGQ0BAdWRUtA21/cR6F+t97KZnVS et225UYv8azv8p8cK4R1lrZXChFadK9Kt+/My4HAx7J7zd1IPuKQ0QniuvuLT3Mw z19B7FGXaJenwTw0P1ihtmSPq9GAOkOA4ZPhHLl9OFwIeAZzjfshRfvm0haO3vwl xdjhwxyJ/a/JEF2ISQQYEQIACQUCQ1AArQIbDAAKCRAulvFBs90rLrBkAJ9tScp6 drhhPQJw1AY6GEpSbK0JtACeJuewK8C1wO1l5OYkGzFpb4VgquI= =twR+ -----END PGP PUBLIC KEY BLOCK----- " gnupg-1.4.0/tests/gnupg_oo_keyinfo.phpt0000664000175000017500000000405112761103324017207 0ustar jakubjakub--TEST--n get keyinfo --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg -> keyinfo($fingerprint); var_dump($ret); ?> --EXPECT-- array(1) { [0]=> array(8) { ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) ["is_secret"]=> bool(false) ["can_sign"]=> bool(true) ["can_encrypt"]=> bool(true) ["uids"]=> array(1) { [0]=> array(6) { ["name"]=> string(7) "testkey" ["comment"]=> string(7) "testkey" ["email"]=> string(16) "test@example.net" ["uid"]=> string(36) "testkey (testkey) " ["revoked"]=> bool(false) ["invalid"]=> bool(false) } } ["subkeys"]=> array(2) { [0]=> array(11) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["keyid"]=> string(16) "2E96F141B3DD2B2E" ["timestamp"]=> int(1129316524) ["expires"]=> int(0) ["is_secret"]=> bool(false) ["invalid"]=> bool(false) ["can_encrypt"]=> bool(false) ["can_sign"]=> bool(true) ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) } [1]=> array(11) { ["fingerprint"]=> string(40) "A3437D3651E27CF9864198F0BFE8D07DDACDEAC8" ["keyid"]=> string(16) "BFE8D07DDACDEAC8" ["timestamp"]=> int(1129316525) ["expires"]=> int(0) ["is_secret"]=> bool(false) ["invalid"]=> bool(false) ["can_encrypt"]=> bool(true) ["can_sign"]=> bool(false) ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) } } } } gnupg-1.4.0/tests/gnupg_oo_listsignatures.phpt0000664000175000017500000000140212761103324020620 0ustar jakubjakub--TEST--n list signatures --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg -> listsignatures($fingerprint); var_dump($ret); ?> --EXPECT-- array(1) { ["testkey (testkey) "]=> array(1) { ["2E96F141B3DD2B2E"]=> array(8) { ["uid"]=> string(36) "testkey (testkey) " ["name"]=> string(7) "testkey" ["email"]=> string(16) "test@example.net" ["comment"]=> string(7) "testkey" ["expires"]=> int(0) ["revoked"]=> bool(false) ["expired"]=> bool(false) ["invalid"]=> bool(false) } } } gnupg-1.4.0/tests/gnupg_oo_sign_clear.phpt0000664000175000017500000000136312761103324017654 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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(8) "foo bar " gnupg-1.4.0/tests/gnupg_oo_sign_detach.phpt0000664000175000017500000000136612761103324020021 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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_sign_detach_nonarmor.phpt0000664000175000017500000000144612761103324021733 0ustar jakubjakub--TEST--n 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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_sign_normal.phpt0000664000175000017500000000142112761103324020051 0ustar jakubjakub--TEST--n 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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_sign_normal_noarmor.phpt0000664000175000017500000000153612761103324021615 0ustar jakubjakub--TEST--n 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 = NULL; $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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_oo_zzz_deletekey.phpt0000664000175000017500000000046612761103324020441 0ustar jakubjakub--TEST--n delete a key from the keyring --SKIPIF-- --FILE-- seterrormode(gnupg::ERROR_WARNING); $ret = $gpg -> deletekey($fingerprint,true); var_dump($ret); ?> --EXPECT-- bool(true) gnupg-1.4.0/tests/gnupg_res_0001_import.phpt0000664000175000017500000000121212761103324017665 0ustar jakubjakub--TEST--n import a new key into the keyring --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) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" } gnupg-1.4.0/tests/gnupg_res_encrypt.phpt0000664000175000017500000000064612761103324017411 0ustar jakubjakub--TEST-- encrypt and decrypt a text --FILE-- --EXPECTF-- string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_encryptsign.phpt0000664000175000017500000000142012761103324020261 0ustar jakubjakub--TEST-- encryptsign and decryptverify a text --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_export.phpt0000664000175000017500000000304612761103324017243 0ustar jakubjakub--TEST-- export a key --FILE-- --EXPECTF-- string(%d) "-----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v1.%d.%d (GNU/Linux) mQGiBENQAKwRBADpy828KU+0SuoetJTrJ5dR86PiO3CsH8K6QRP7wY82Eh/9NTJ3 afRj0FNPaVSP0NciPeM4G4uFoQ3lsIf+FBEPXH1D97/XigWObU8K6ha2/s8wU98z /samjTHLR+VKZ031B5/8p5Y49yvkkEyBkF1G85yeIXK0WZorKBPncRKuUwCgxOi/ IEa+ZuqHlmlDF2LTRIBOfrkEAK+WLRMWUD0bqj1TYwnxwPWiuns32/ZXLWuPfb5o crNt7x5LSe7wJhjyIiFhiU0qR33X/FrT2umzOxlRYfINXT9DUHDocxxbED6fxAHw X2IDd5tWXgCkSBHn2yAneNY6ycPdS3RvqJGlYFg7cOc0kz4urjqRt9fIagzpZQtL fXHfBACl3EWgvLhVBo5ExZbrtlOA2q0x9UGhhNaSkeBWBr2qDeZErQjMTO0+viaN /SX0zxeWtM3z06rkUHd1DKORDRM5R7shBTv9/Quojn0gbYbOem+e1mlCe27TRxcP yeIKk00PqbVuff9QlK9GqKEWGzsEXCmxZ160Dul3CGlf/vQZHbQkdGVzdGtleSAo dGVzdGtleSkgPHRlc3RAZXhhbXBsZS5uZXQ+iF4EExECAB4FAkNQAKwCGwMGCwkI BwMCAxUCAwMWAgECHgECF4AACgkQLpbxQbPdKy58pwCcDz9qEBEVt1gcKCwNay0f m4vLqCkAn1P0KV1giECUVXBuZ5YUndDB1QqtuQENBENQAK0QBACNXzJQG4NHUJqL PImezbl+ii+93MjMo8LpSlv9Np5ruWIKtxuqmVEe4k+r1DDmSl8hppifpRtx2hef bDTl8Tdf5MNGvf5JE3AHYUehZ+ldjgYCOZ53fJDgKV65ZidQSGGXsRcyE7SHgMQ6 rTL92PA2IQmkcf9xkg6xM2h55UusMwADBQP9EGQ0BAdWRUtA21/cR6F+t97KZnVS et225UYv8azv8p8cK4R1lrZXChFadK9Kt+/My4HAx7J7zd1IPuKQ0QniuvuLT3Mw z19B7FGXaJenwTw0P1ihtmSPq9GAOkOA4ZPhHLl9OFwIeAZzjfshRfvm0haO3vwl xdjhwxyJ/a/JEF2ISQQYEQIACQUCQ1AArQIbDAAKCRAulvFBs90rLrBkAJ9tScp6 drhhPQJw1AY6GEpSbK0JtACeJuewK8C1wO1l5OYkGzFpb4VgquI= =twR+ -----END PGP PUBLIC KEY BLOCK----- " gnupg-1.4.0/tests/gnupg_res_keyinfo.phpt0000664000175000017500000000376512761103324017376 0ustar jakubjakub--TEST--n get keyinfo --FILE-- --EXPECT-- array(1) { [0]=> array(8) { ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) ["is_secret"]=> bool(false) ["can_sign"]=> bool(true) ["can_encrypt"]=> bool(true) ["uids"]=> array(1) { [0]=> array(6) { ["name"]=> string(7) "testkey" ["comment"]=> string(7) "testkey" ["email"]=> string(16) "test@example.net" ["uid"]=> string(36) "testkey (testkey) " ["revoked"]=> bool(false) ["invalid"]=> bool(false) } } ["subkeys"]=> array(2) { [0]=> array(11) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["keyid"]=> string(16) "2E96F141B3DD2B2E" ["timestamp"]=> int(1129316524) ["expires"]=> int(0) ["is_secret"]=> bool(false) ["invalid"]=> bool(false) ["can_encrypt"]=> bool(false) ["can_sign"]=> bool(true) ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) } [1]=> array(11) { ["fingerprint"]=> string(40) "A3437D3651E27CF9864198F0BFE8D07DDACDEAC8" ["keyid"]=> string(16) "BFE8D07DDACDEAC8" ["timestamp"]=> int(1129316525) ["expires"]=> int(0) ["is_secret"]=> bool(false) ["invalid"]=> bool(false) ["can_encrypt"]=> bool(true) ["can_sign"]=> bool(false) ["disabled"]=> bool(false) ["expired"]=> bool(false) ["revoked"]=> bool(false) } } } } gnupg-1.4.0/tests/gnupg_res_listsignatures.phpt0000664000175000017500000000131612761103324021000 0ustar jakubjakub--TEST--n list signatures --FILE-- --EXPECT-- array(1) { ["testkey (testkey) "]=> array(1) { ["2E96F141B3DD2B2E"]=> array(8) { ["uid"]=> string(36) "testkey (testkey) " ["name"]=> string(7) "testkey" ["email"]=> string(16) "test@example.net" ["comment"]=> string(7) "testkey" ["expires"]=> int(0) ["revoked"]=> bool(false) ["expired"]=> bool(false) ["invalid"]=> bool(false) } } } gnupg-1.4.0/tests/gnupg_res_sign_clear.phpt0000664000175000017500000000131312761103324020023 0ustar jakubjakub--TEST--n sign a text with sigmode SIG_MODE_CLEAR --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(8) "foo bar " gnupg-1.4.0/tests/gnupg_res_sign_detach.phpt0000664000175000017500000000131512761103324020167 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_DETACH --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_sign_detach_nonarmor.phpt0000664000175000017500000000140212761103324022077 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_DETACH and without armored output --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_sign_normal.phpt0000664000175000017500000000135012761103324020226 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_NORMAL --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_sign_normal_noarmor.phpt0000664000175000017500000000141712761103324021767 0ustar jakubjakub--TEST--n sign a text with mode SIG_MODE_NORMAL and without armored output --FILE-- --EXPECTF-- array(1) { [0]=> array(5) { ["fingerprint"]=> string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E" ["validity"]=> int(0) ["timestamp"]=> int(%d) ["status"]=> int(0) ["summary"]=> int(0) } } string(7) "foo bar" gnupg-1.4.0/tests/gnupg_res_zzz_deletekey.phpt0000664000175000017500000000040212761103324020603 0ustar jakubjakub--TEST--n delete a key from the keyring --FILE-- --EXPECT-- bool(true) gnupg-1.4.0/tests/vars.inc0000664000175000017500000000330312761103324014416 0ustar jakubjakub gnupg-1.4.0/config.m40000664000175000017500000000354612761103324013326 0ustar jakubjakubdnl $Id$ dnl config.m4 for extension gnupg AC_CANONICAL_HOST case $host_os in *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/include /usr/include /usr/local/include/gpgme/ /usr/include/gpgme/" SEARCH_FOR="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 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) LIBNAME=gpgme LIBSYMBOL=gpgme_check_version PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL, [ PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $GNUPG_DIR/lib, GNUPG_SHARED_LIBADD) AC_DEFINE(HAVE_GNUPGLIB,1,[ ]) ],[ AC_MSG_ERROR([wrong gpgme lib version or lib not found]) ],[ -L$GNUPG_DIR/lib -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 v1.x]) fi fi gnupg-1.4.0/EXPERIMENTAL0000664000175000017500000000000012761103324013415 0ustar jakubjakubgnupg-1.4.0/gnupg.c0000664000175000017500000013766712761103324013117 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) /* }}} */ /* {{{ gnupg_free_encryptkeys */ static void 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]); } /* it's an odd-thing, but other solutions makes problems : * erealloc(x,0) gives a segfault with PHP 4 and debug enabled * efree(x) alone ends in a segfault */ efree(erealloc(PHPC_THIS->encryptkeys, 0)); PHPC_THIS->encryptkeys = NULL; PHPC_THIS->encrypt_size = 0; } } /* }}} */ /* {{{ gnupg_free_resource_ptre */ static void gnupg_free_resource_ptr(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 */ 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); } } /* }}} */ /* {{{ gnupg_res_dtor */ static void gnupg_res_dtor(phpc_res_entry_t *rsrc TSRMLS_DC) /* {{{ */ { PHPC_THIS_DECLARE(gnupg) = rsrc->ptr; gnupg_free_resource_ptr(PHPC_THIS TSRMLS_CC); efree(PHPC_THIS); } /* }}} */ /* {{{ gnupg_res_init */ static void gnupg_res_init(PHPC_THIS_DECLARE(gnupg) TSRMLS_DC) { /* init the gpgme-lib and set the default values */ gpgme_ctx_t ctx; gpgme_error_t err; gpgme_check_version(NULL); err = gpgme_new(&ctx); if (err == GPG_ERR_NO_ERROR) { #ifdef GNUPG_PATH gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, GNUPG_PATH, NULL); #endif gpgme_set_armor(ctx,1); } PHPC_THIS->ctx = ctx; PHPC_THIS->encryptkeys = NULL; PHPC_THIS->encrypt_size = 0; PHPC_THIS->signmode = GPGME_SIG_MODE_CLEAR; 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); } /* }}} */ /* {{{ free gnupg */ PHPC_OBJ_HANDLER_FREE(gnupg) { PHPC_OBJ_HANDLER_FREE_INIT(gnupg); gnupg_free_resource_ptr(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); gnupg_res_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 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 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() /* }}} */ /* {{{ methodlist gnupg */ phpc_function_entry gnupg_methods[] = { PHP_FALIAS(keyinfo, gnupg_keyinfo, NULL) PHP_FALIAS(verify, gnupg_verify, arginfo_gnupg_verify_method) PHP_FALIAS(geterror, gnupg_geterror, NULL) PHP_FALIAS(clearsignkeys, gnupg_clearsignkeys, NULL) PHP_FALIAS(clearencryptkeys, gnupg_clearencryptkeys, NULL) PHP_FALIAS(cleardecryptkeys, gnupg_cleardecryptkeys, NULL) PHP_FALIAS(setarmor, gnupg_setarmor, NULL) PHP_FALIAS(encrypt, gnupg_encrypt, NULL) PHP_FALIAS(decrypt, gnupg_decrypt, NULL) PHP_FALIAS(export, gnupg_export, NULL) PHP_FALIAS(import, gnupg_import, NULL) PHP_FALIAS(getprotocol, gnupg_getprotocol, NULL) PHP_FALIAS(setsignmode, gnupg_setsignmode, NULL) PHP_FALIAS(sign, gnupg_sign, NULL) PHP_FALIAS(encryptsign, gnupg_encryptsign, NULL) PHP_FALIAS(decryptverify, gnupg_decryptverify, arginfo_gnupg_decryptverify_method) PHP_FALIAS(addsignkey, gnupg_addsignkey, NULL) PHP_FALIAS(addencryptkey, gnupg_addencryptkey, NULL) PHP_FALIAS(adddecryptkey, gnupg_adddecryptkey, NULL) PHP_FALIAS(deletekey, gnupg_deletekey, NULL) PHP_FALIAS(gettrustlist, gnupg_gettrustlist, NULL) PHP_FALIAS(listsignatures, gnupg_listsignatures, NULL) PHP_FALIAS(seterrormode, gnupg_seterrormode, NULL) PHPC_FE_END }; /* }}} */ /* {{{ arginfo gnupg_verify_method */ 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_method */ 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, NULL) PHP_FE(gnupg_keyinfo, NULL) PHP_FE(gnupg_sign, NULL) PHP_FE(gnupg_verify, arginfo_gnupg_verify_function) PHP_FE(gnupg_clearsignkeys, NULL) PHP_FE(gnupg_clearencryptkeys, NULL) PHP_FE(gnupg_cleardecryptkeys, NULL) PHP_FE(gnupg_setarmor, NULL) PHP_FE(gnupg_encrypt, NULL) PHP_FE(gnupg_decrypt, NULL) PHP_FE(gnupg_export, NULL) PHP_FE(gnupg_import, NULL) PHP_FE(gnupg_getprotocol, NULL) PHP_FE(gnupg_setsignmode, NULL) PHP_FE(gnupg_encryptsign, NULL) PHP_FE(gnupg_decryptverify, arginfo_gnupg_decryptverify_function) PHP_FE(gnupg_geterror, NULL) PHP_FE(gnupg_addsignkey, NULL) PHP_FE(gnupg_addencryptkey, NULL) PHP_FE(gnupg_adddecryptkey, NULL) PHP_FE(gnupg_deletekey, NULL) PHP_FE(gnupg_gettrustlist, NULL) PHP_FE(gnupg_listsignatures, NULL) PHP_FE(gnupg_seterrormode, NULL) {NULL, NULL, NULL} }; /* }}} */ /* {{{ 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 /* {{{ class constants */ static inline void gnupg_declare_long_constant(const char *const_name, long value TSRMLS_DC) { zend_declare_class_constant_long(gnupg_class_entry, (char*)const_name, strlen(const_name), value TSRMLS_CC); } /* }}} */ /* {{{ PHP_MINIT_FUNCTION */ PHP_MINIT_FUNCTION(gnupg) { zend_class_entry ce; /* 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(gnupg_res_dtor, NULL, "ctx", module_number); if (SUCCESS != gnupg_keylistiterator_init()) { return FAILURE; } gnupg_declare_long_constant("SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL TSRMLS_CC); gnupg_declare_long_constant("SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH TSRMLS_CC); gnupg_declare_long_constant("SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_NEVER", GPGME_VALIDITY_NEVER TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_FULL", GPGME_VALIDITY_FULL TSRMLS_CC); gnupg_declare_long_constant("VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE TSRMLS_CC); gnupg_declare_long_constant("PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP TSRMLS_CC); gnupg_declare_long_constant("PROTOCOL_CMS", GPGME_PROTOCOL_CMS TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_VALID", GPGME_SIGSUM_VALID TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_GREEN", GPGME_SIGSUM_GREEN TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_RED", GPGME_SIGSUM_RED TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY TSRMLS_CC); gnupg_declare_long_constant("SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR TSRMLS_CC); gnupg_declare_long_constant("ERROR_WARNING", 1 TSRMLS_CC); gnupg_declare_long_constant("ERROR_EXCEPTION", 2 TSRMLS_CC); gnupg_declare_long_constant("ERROR_SILENT", 3 TSRMLS_CC); REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_NEVER", GPGME_VALIDITY_NEVER, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_FULL", GPGME_VALIDITY_FULL, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_PROTOCOL_CMS", GPGME_PROTOCOL_CMS, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_VALID", GPGME_SIGSUM_VALID, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_GREEN", GPGME_SIGSUM_GREEN, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_RED", GPGME_SIGSUM_RED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_WARNING", 1, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_EXCEPTION", 2, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("GNUPG_ERROR_SILENT", 3, CONST_CS | CONST_PERSISTENT); 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)); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "fingerprint", gpgme_signatures->fpr); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "validity", gpgme_signatures->validity); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "timestamp", gpgme_signatures->timestamp); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "status", gpgme_signatures->status); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "summary", gpgme_signatures->summary); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(main_arr, PHPC_VAL_CAST_TO_PZVAL(sig_arr)); gpgme_signatures = gpgme_signatures->next; } return 1; } /* }}} */ /* {{{ proto resource gnupg_init() * inits gnupg and returns a resource */ PHP_FUNCTION(gnupg_init) { PHPC_THIS_DECLARE(gnupg); PHPC_THIS = emalloc(sizeof(PHPC_OBJ_STRUCT_NAME(gnupg))); gnupg_res_init(PHPC_THIS 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 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 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) * 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; 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 ((PHPC_THIS->err = gpgme_op_keylist_start(PHPC_THIS->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not init keylist"); return; } PHPC_ARRAY_INIT(return_value); while (!(PHPC_THIS->err = 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)); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "disabled", gpgme_key->disabled); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "expired", gpgme_key->expired); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "revoked", gpgme_key->revoked); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "is_secret", gpgme_key->secret); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "can_sign", gpgme_key->can_sign); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "can_encrypt", gpgme_key->can_encrypt); gpgme_userid = gpgme_key->uids; while (gpgme_userid) { PHPC_VAL_MAKE(userid); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(userid)); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "name", gpgme_userid->name); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "comment", gpgme_userid->comment); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "email", gpgme_userid->email); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "uid", gpgme_userid->uid); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(userid), "revoked", gpgme_userid->revoked); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(userid), "invalid", gpgme_userid->invalid); 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) { PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(subkey), "fingerprint", gpgme_subkey->fpr); } PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(subkey), "keyid", gpgme_subkey->keyid); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(subkey), "timestamp", gpgme_subkey->timestamp); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(subkey), "expires", gpgme_subkey->expires); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "is_secret", gpgme_subkey->secret); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "invalid", gpgme_subkey->invalid); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "can_encrypt", gpgme_subkey->can_encrypt); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "can_sign", gpgme_subkey->can_sign); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "disabled", gpgme_subkey->disabled); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "expired", gpgme_subkey->expired); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "revoked", gpgme_subkey->revoked); 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 ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_signers_add(PHPC_THIS->ctx, gpgme_key)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) { 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; 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 ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("get_key failed"); return; } PHPC_THIS->encryptkeys = erealloc(PHPC_THIS->encryptkeys, sizeof(PHPC_THIS->encryptkeys) * (PHPC_THIS->encrypt_size + 2)); 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(); } 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&in, value, value_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create in-data buffer"); return; } 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 ((PHPC_THIS->err = gpgme_op_sign(PHPC_THIS->ctx, in, out, PHPC_THIS->signmode)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&in, value, value_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could no create in-data buffer"); return; } 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 ((PHPC_THIS->err = gpgme_op_encrypt(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("encrypt failed"); 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 ((PHPC_THIS->err = gpgme_data_new_from_mem (&in, value, value_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create in-data buffer"); return; } 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 ((PHPC_THIS->err = gpgme_op_encrypt_sign(PHPC_THIS->ctx, PHPC_THIS->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&gpgme_sig, Z_STRVAL_P(signature), Z_STRLEN_P(signature), 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create signature-databuffer"); return; } /* and the text */ if ((PHPC_THIS->err = gpgme_data_new_from_mem(&gpgme_text, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create text-databuffer"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } /* now verify sig + text */ if ((PHPC_THIS->err = gpgme_op_verify (PHPC_THIS->ctx, gpgme_sig, gpgme_text, NULL)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("verify failed"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } } else { /* clearsign or normal signature */ if ((PHPC_THIS->err = gpgme_data_new_from_mem(&gpgme_sig, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create signature-databuffer"); return; } /* set a NULL databuffer for gpgme */ if ((PHPC_THIS->err = gpgme_data_new_from_mem(&gpgme_text, NULL, 0, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create text-databuffer"); gpgme_data_release(gpgme_sig); gpgme_data_release(gpgme_text); return; } /* and verify the 'signature' */ if ((PHPC_THIS->err = gpgme_op_verify(PHPC_THIS->ctx, gpgme_sig, NULL, gpgme_text)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&in, enctxt, enctxt_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create in-data buffer"); } 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 ((PHPC_THIS->err = gpgme_op_decrypt(PHPC_THIS->ctx, in, out)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&in, enctxt, enctxt_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create in-data buffer"); } 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 ((PHPC_THIS->err = gpgme_op_decrypt_verify(PHPC_THIS->ctx, in, out)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new(&out)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create data buffer"); return; } if ((PHPC_THIS->err = gpgme_op_export(PHPC_THIS->ctx, searchkey, 0, out)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_data_new_from_mem(&in, importkey, importkey_len, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not create in-data buffer"); return; } if ((PHPC_THIS->err = gpgme_op_import(PHPC_THIS->ctx,in)) != GPG_ERR_NO_ERROR) { 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); } } /* }}} */ /* {{{ proto book gnupg_deletekey(string key) * deletes a key from the keyring */ PHP_FUNCTION(gnupg_deletekey) { char *key; phpc_str_size_t key_len; phpc_long_t allow_secret = 0; gpgme_key_t gpgme_key; GNUPG_GETOBJ(); if (this) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &key, &key_len, &allow_secret) == FAILURE) { return; } } else { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE) { return; } GNUPG_RES_FETCH(); } if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("get_key failed"); return; } if ((PHPC_THIS->err = gpgme_op_delete(PHPC_THIS->ctx,gpgme_key,allow_secret)) != GPG_ERR_NO_ERROR) { 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 ((PHPC_THIS->err = gpgme_op_trustlist_start (PHPC_THIS->ctx, pattern, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not start trustlist"); return; } PHPC_ARRAY_INIT(return_value); while (!(PHPC_THIS->err = gpgme_op_trustlist_next (PHPC_THIS->ctx, &item))) { PHPC_VAL_MAKE(sub_arr); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(sub_arr)); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "level", item->level); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "type", item->type); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "keyid", item->keyid); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "ownertrust", item->owner_trust); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "validity", item->validity); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sub_arr), "name", item->name); 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 ((PHPC_THIS->err = gpgme_set_keylist_mode(PHPC_THIS->ctx, GPGME_KEYLIST_MODE_SIGS)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("could not switch to sigmode"); return; } if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, keyid, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) { GNUPG_ERR("get_key failed. given key not unique?"); 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)); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "uid", gpgme_signature->uid); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "name", gpgme_signature->name); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "email", gpgme_signature->email); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "comment", gpgme_signature->comment); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "expires", gpgme_signature->expires); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "revoked", gpgme_signature->revoked); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "expired", gpgme_signature->expired); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(sig_arr), "invalid", gpgme_signature->invalid); 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.4.0/gnupg_keylistiterator.c0000664000175000017500000001277412761103324016424 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); } /* {{{ method list gnupg_keylistiterator */ static zend_function_entry gnupg_keylistiterator_methods[] = { PHP_ME(gnupg_keylistiterator, __construct, NULL, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, current, NULL, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, key, NULL, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, next, NULL, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, rewind, NULL, ZEND_ACC_PUBLIC) PHP_ME(gnupg_keylistiterator, valid, NULL, 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.4.0/LICENSE0000664000175000017500000000747112761103324012625 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.4.0/php_gnupg_keylistiterator.h0000664000175000017500000000365012761103324017271 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.4.0/php_gnupg.h0000664000175000017500000000475312761103324013760 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.4.0" #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_FUNCTION(gnupg_keyinfo); PHP_FUNCTION(gnupg_verify); PHP_FUNCTION(gnupg_geterror); 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.4.0/php_gnupg_keylistiterator.h0000664000175000017500000000365012761103324017271 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.4.0/README0000664000175000017500000000056212761103324012472 0ustar jakubjakubA documentation how to install a PECL-Extension is available in the PHP-Manual http://www.php.net/manual/en/install.pecl.php The extension documentation is now available in the PHP-Manual: http://php.net/manual/en/book.gnupg.php The extension supports only gnupg version 1 and the version 2 is not currently supported. It should be fixed in the extension version 1.5. gnupg-1.4.0/UPGRADING0000664000175000017500000000046212761103324013054 0ustar jakubjakubPHP GNUPG UPGRADING NOTES This document lists backward incompatible change in the extension 1.4.0 - gnupg_decryptverify $plaintext reference cannot be longer 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.