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

Port to phpc some functions and fix CS

Browse source
This commit is contained in:
Jakub Zelenka 2016-05-22 12:07:13 +01:00
parent fdf573ac73
commit 4229b54fd6
2 changed files with 453 additions and 425 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

360
gnupg.c
View file

@ -48,6 +48,9 @@ PHPC_OBJ_DEFINE_HANDLER_VAR(gnupg);
} while (0) } while (0)
/* }}} */ /* }}} */
#define GNUPG_RES_FETCH() \
PHPC_THIS = (PHPC_OBJ_STRUCT_NAME(gnupg) *) PHPC_RES_FETCH(res, "ctx", le_gnupg)
/* {{{ GNUPG_ERR */ /* {{{ GNUPG_ERR */
#define GNUPG_ERR(error) \ #define GNUPG_ERR(error) \
if (PHPC_THIS) { \ if (PHPC_THIS) { \
@ -389,9 +392,11 @@ PHP_MINFO_FUNCTION(gnupg)
} }
/* }}} */ /* }}} */
/* {{{ callback func for setting the passphrase */ /* {{{ passphrase_cb */
gpgme_error_t passphrase_cb(
gpgme_error_t passphrase_cb(PHPC_THIS_DECLARE(gnupg), const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC) PHPC_THIS_DECLARE(gnupg),
const char *uid_hint, const char *passphrase_info,
int last_was_bad, int fd TSRMLS_DC)
{ {
char uid[17]; char uid[17];
int idx; int idx;
@ -415,15 +420,20 @@ gpgme_error_t passphrase_cb(PHPC_THIS_DECLARE(gnupg), const char *uid_hint, cons
return 1; return 1;
} }
if (write (fd, passphrase, strlen(passphrase))==strlen(passphrase) if (write(fd, passphrase, strlen(passphrase)) == strlen(passphrase) && write(fd, "\n", 1) == 1) {
&& write (fd, "\n", 1)==1) {
return 0; return 0;
} }
GNUPG_ERR("write failed"); GNUPG_ERR("write failed");
return 1; return 1;
} }
/* }}} */
gpgme_error_t passphrase_decrypt_cb (PHPC_THIS_DECLARE(gnupg), const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC){ /* {{{ passphrase_decrypt_cb */
gpgme_error_t passphrase_decrypt_cb (
PHPC_THIS_DECLARE(gnupg),
const char *uid_hint, const char *passphrase_info,
int last_was_bad, int fd TSRMLS_DC)
{
char uid[17]; char uid[17];
int idx; int idx;
char *passphrase = NULL; char *passphrase = NULL;
@ -445,29 +455,28 @@ gpgme_error_t passphrase_decrypt_cb (PHPC_THIS_DECLARE(gnupg), const char *uid_h
GNUPG_ERR("no passphrase set"); GNUPG_ERR("no passphrase set");
return 1; return 1;
} }
if (write (fd, passphrase, strlen(passphrase))==strlen(passphrase) if (write(fd, passphrase, strlen(passphrase)) == strlen(passphrase) && write(fd, "\n", 1) == 1) {
&& write (fd, "\n", 1)==1) {
return 0; return 0;
} }
GNUPG_ERR("write failed"); GNUPG_ERR("write failed");
return 1; return 1;
} }
/* }}} */ /* }}} */
/* {{{ gnupg_fetchsignatures */ /* {{{ gnupg_fetchsignatures */
int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr){ int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr)
{
zval sig_arr; zval sig_arr;
array_init (main_arr); PHPC_ARRAY_INIT(main_arr);
while (gpgme_signatures) { while (gpgme_signatures) {
array_init (&sig_arr); PHPC_ARRAY_INIT(&sig_arr);
add_assoc_string (&sig_arr, "fingerprint", gpgme_signatures->fpr ); PHPC_ARRAY_ADD_ASSOC_CSTR(&sig_arr, "fingerprint", gpgme_signatures->fpr);
add_assoc_long (&sig_arr, "validity", gpgme_signatures->validity ); PHPC_ARRAY_ADD_ASSOC_LONG(&sig_arr, "validity", gpgme_signatures->validity);
add_assoc_long (&sig_arr, "timestamp", gpgme_signatures->timestamp ); PHPC_ARRAY_ADD_ASSOC_LONG(&sig_arr, "timestamp", gpgme_signatures->timestamp);
add_assoc_long (&sig_arr, "status", gpgme_signatures->status ); PHPC_ARRAY_ADD_ASSOC_LONG(&sig_arr, "status", gpgme_signatures->status);
add_assoc_long (&sig_arr, "summary", gpgme_signatures->summary ); PHPC_ARRAY_ADD_ASSOC_LONG(&sig_arr, "summary", gpgme_signatures->summary);
add_next_index_zval (main_arr, &sig_arr); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(main_arr, &sig_arr);
gpgme_signatures = gpgme_signatures->next; gpgme_signatures = gpgme_signatures->next;
} }
@ -478,11 +487,12 @@ int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr){
/* {{{ proto resource gnupg_init() /* {{{ proto resource gnupg_init()
* inits gnupg and returns a resource * inits gnupg and returns a resource
*/ */
PHP_FUNCTION(gnupg_init){ PHP_FUNCTION(gnupg_init)
{
PHPC_THIS_DECLARE(gnupg); PHPC_THIS_DECLARE(gnupg);
PHPC_THIS = emalloc(sizeof(gnupg_object)); PHPC_THIS = emalloc(sizeof(PHPC_OBJ_STRUCT_NAME(gnupg)));
gnupg_res_init(PHPC_THIS TSRMLS_CC); gnupg_res_init(PHPC_THIS TSRMLS_CC);
RETURN_RES(zend_register_resource(PHPC_THIS,le_gnupg)); PHPC_RES_RETURN(PHPC_RES_REGISTER(PHPC_THIS, le_gnupg));
} }
/* }}} */ /* }}} */
@ -491,8 +501,9 @@ PHP_FUNCTION(gnupg_init){
* 0 = off * 0 = off
* >0 = on * >0 = on
* */ * */
PHP_FUNCTION(gnupg_setarmor){ PHP_FUNCTION(gnupg_setarmor)
zend_long armor; {
phpc_long_t armor;
GNUPG_GETOBJ(); GNUPG_GETOBJ();
@ -504,7 +515,7 @@ PHP_FUNCTION(gnupg_setarmor){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if (armor > 1) { if (armor > 1) {
@ -517,8 +528,9 @@ PHP_FUNCTION(gnupg_setarmor){
/* }}} */ /* }}} */
/* {{{ proto bool gnupg_seterrormode(int errormde) */ /* {{{ proto bool gnupg_seterrormode(int errormde) */
PHP_FUNCTION(gnupg_seterrormode){ PHP_FUNCTION(gnupg_seterrormode)
zend_long errormode; {
phpc_long_t errormode;
GNUPG_GETOBJ(); GNUPG_GETOBJ();
@ -530,7 +542,7 @@ PHP_FUNCTION(gnupg_seterrormode){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
switch (errormode) { switch (errormode) {
@ -544,13 +556,15 @@ PHP_FUNCTION(gnupg_seterrormode){
default: default:
GNUPG_ERR("invalid errormode"); GNUPG_ERR("invalid errormode");
} }
RETURN_TRUE;
} }
/* }}} */ /* }}} */
/* {{{ proto bool gnupg_setsignmode(int signmode) /* {{{ proto bool gnupg_setsignmode(int signmode)
* sets the mode for signing operations * sets the mode for signing operations
*/ */
PHP_FUNCTION(gnupg_setsignmode){ PHP_FUNCTION(gnupg_setsignmode)
{
zend_long signmode; zend_long signmode;
GNUPG_GETOBJ(); GNUPG_GETOBJ();
@ -563,7 +577,7 @@ PHP_FUNCTION(gnupg_setsignmode){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); PHPC_THIS = (gnupg_object *) PHPC_RES_FETCH(res, "ctx", le_gnupg);
} }
switch (signmode) { switch (signmode) {
case GPGME_SIG_MODE_NORMAL: case GPGME_SIG_MODE_NORMAL:
@ -577,25 +591,27 @@ PHP_FUNCTION(gnupg_setsignmode){
RETVAL_FALSE; RETVAL_FALSE;
break; break;
} }
RETURN_TRUE;
} }
/* }}} */ /* }}} */
/* {{{ proto string gnupg_geterror(void) /* {{{ proto string gnupg_geterror(void)
* returns the last errormessage * returns the last errormessage
*/ */
PHP_FUNCTION(gnupg_geterror){ PHP_FUNCTION(gnupg_geterror)
{
GNUPG_GETOBJ(); GNUPG_GETOBJ();
if (!this) { if (!this) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if (!PHPC_THIS->errortxt) { if (!PHPC_THIS->errortxt) {
RETURN_FALSE; RETURN_FALSE;
} else { } else {
RETURN_STRINGL(PHPC_THIS->errortxt, strlen(PHPC_THIS->errortxt)); PHPC_CSTR_RETURN(PHPC_THIS->errortxt);
} }
} }
/* }}} */ /* }}} */
@ -616,13 +632,8 @@ PHP_FUNCTION(gnupg_getprotocol){
PHP_FUNCTION(gnupg_keyinfo) PHP_FUNCTION(gnupg_keyinfo)
{ {
char *searchkey = NULL; char *searchkey = NULL;
size_t searchkey_len; phpc_str_size_t searchkey_len;
zval subarr; phpc_val subarr, userid, userids, subkey, subkeys;
zval userid;
zval userids;
zval subkey;
zval subkeys;
gpgme_key_t gpgme_key; gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey; gpgme_subkey_t gpgme_subkey;
gpgme_user_id_t gpgme_userid; gpgme_user_id_t gpgme_userid;
@ -637,87 +648,90 @@ PHP_FUNCTION(gnupg_keyinfo)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_op_keylist_start(PHPC_THIS->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_op_keylist_start(PHPC_THIS->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR) {
GNUPG_ERR("could not init keylist"); GNUPG_ERR("could not init keylist");
return; return;
} }
array_init(return_value); PHPC_ARRAY_INIT(return_value);
while (!(PHPC_THIS->err = gpgme_op_keylist_next(PHPC_THIS->ctx, &gpgme_key))) { while (!(PHPC_THIS->err = gpgme_op_keylist_next(PHPC_THIS->ctx, &gpgme_key))) {
array_init (&subarr); PHPC_VAL_MAKE(subarr);
PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subarr));
array_init (&subkeys); PHPC_VAL_MAKE(subkeys);
PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subkeys));
array_init (&userids); PHPC_VAL_MAKE(userids);
PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(userids));
add_assoc_bool (&subarr, "disabled", gpgme_key->disabled ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "disabled", gpgme_key->disabled);
add_assoc_bool (&subarr, "expired", gpgme_key->expired ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "expired", gpgme_key->expired);
add_assoc_bool (&subarr, "revoked", gpgme_key->revoked ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "revoked", gpgme_key->revoked);
add_assoc_bool (&subarr, "is_secret", gpgme_key->secret ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "is_secret", gpgme_key->secret);
add_assoc_bool (&subarr, "can_sign", gpgme_key->can_sign ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "can_sign", gpgme_key->can_sign);
add_assoc_bool (&subarr, "can_encrypt", gpgme_key->can_encrypt ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subarr), "can_encrypt", gpgme_key->can_encrypt);
gpgme_userid = gpgme_key->uids; gpgme_userid = gpgme_key->uids;
while (gpgme_userid) { while (gpgme_userid) {
array_init (&userid); PHPC_VAL_MAKE(userid);
PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(userid));
add_assoc_string (&userid, "name", gpgme_userid->name ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "name", gpgme_userid->name);
add_assoc_string (&userid, "comment", gpgme_userid->comment ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "comment", gpgme_userid->comment);
add_assoc_string (&userid, "email", gpgme_userid->email ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "email", gpgme_userid->email);
add_assoc_string (&userid, "uid", gpgme_userid->uid ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(userid), "uid", gpgme_userid->uid);
add_assoc_bool (&userid, "revoked", gpgme_userid->revoked ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(userid), "revoked", gpgme_userid->revoked);
add_assoc_bool (&userid, "invalid", gpgme_userid->invalid ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(userid), "invalid", gpgme_userid->invalid);
add_next_index_zval (&userids, &userid); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(PHPC_VAL_CAST_TO_PZVAL(userids), PHPC_VAL_CAST_TO_PZVAL(userid));
gpgme_userid = gpgme_userid->next; gpgme_userid = gpgme_userid->next;
} }
add_assoc_zval (&subarr, "uids", &userids); add_assoc_zval(PHPC_VAL_CAST_TO_PZVAL(subarr), "uids", PHPC_VAL_CAST_TO_PZVAL(userids));
gpgme_subkey = gpgme_key->subkeys; gpgme_subkey = gpgme_key->subkeys;
while (gpgme_subkey) { while (gpgme_subkey) {
array_init (&subkey); PHPC_ARRAY_INIT(PHPC_VAL_CAST_TO_PZVAL(subkey));
if (gpgme_subkey->fpr) { if (gpgme_subkey->fpr) {
add_assoc_string (&subkey, "fingerprint", gpgme_subkey->fpr ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(subkey), "fingerprint", gpgme_subkey->fpr);
} }
add_assoc_string (&subkey, "keyid", gpgme_subkey->keyid ); PHPC_ARRAY_ADD_ASSOC_CSTR(PHPC_VAL_CAST_TO_PZVAL(subkey), "keyid", gpgme_subkey->keyid);
add_assoc_long (&subkey, "timestamp", gpgme_subkey->timestamp ); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(subkey), "timestamp", gpgme_subkey->timestamp);
add_assoc_long (&subkey, "expires", gpgme_subkey->expires ); PHPC_ARRAY_ADD_ASSOC_LONG(PHPC_VAL_CAST_TO_PZVAL(subkey), "expires", gpgme_subkey->expires);
add_assoc_bool (&subkey, "is_secret", gpgme_subkey->secret ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "is_secret", gpgme_subkey->secret);
add_assoc_bool (&subkey, "invalid", gpgme_subkey->invalid ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "invalid", gpgme_subkey->invalid);
add_assoc_bool (&subkey, "can_encrypt", gpgme_subkey->can_encrypt ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "can_encrypt", gpgme_subkey->can_encrypt);
add_assoc_bool (&subkey, "can_sign", gpgme_subkey->can_sign ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "can_sign", gpgme_subkey->can_sign);
add_assoc_bool (&subkey, "disabled", gpgme_subkey->disabled ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "disabled", gpgme_subkey->disabled);
add_assoc_bool (&subkey, "expired", gpgme_subkey->expired ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "expired", gpgme_subkey->expired);
add_assoc_bool (&subkey, "revoked", gpgme_subkey->revoked ); PHPC_ARRAY_ADD_ASSOC_BOOL(PHPC_VAL_CAST_TO_PZVAL(subkey), "revoked", gpgme_subkey->revoked);
add_next_index_zval (&subkeys, &subkey); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(PHPC_VAL_CAST_TO_PZVAL(subkeys), PHPC_VAL_CAST_TO_PZVAL(subkey));
gpgme_subkey = gpgme_subkey->next; gpgme_subkey = gpgme_subkey->next;
} }
add_assoc_zval (&subarr, "subkeys", &subkeys); add_assoc_zval(PHPC_VAL_CAST_TO_PZVAL(subarr), "subkeys", PHPC_VAL_CAST_TO_PZVAL(subkeys));
add_next_index_zval (return_value, &subarr); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL(return_value, PHPC_VAL_CAST_TO_PZVAL(subarr));
gpgme_key_unref(gpgme_key); gpgme_key_unref(gpgme_key);
} }
return;
} }
/* }}} */ /* }}} */
/* {{{ proto bool gnupg_addsignkey(string key) */ /* {{{ proto bool gnupg_addsignkey(string key) */
PHP_FUNCTION(gnupg_addsignkey){ PHP_FUNCTION(gnupg_addsignkey)
{
char *key_id = NULL; char *key_id = NULL;
size_t key_id_len; phpc_str_size_t key_id_len;
char *passphrase = NULL; char *passphrase = NULL;
size_t passphrase_len; phpc_str_size_t passphrase_len;
gpgme_key_t gpgme_key; gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey; gpgme_subkey_t gpgme_subkey;
@ -731,7 +745,7 @@ PHP_FUNCTION(gnupg_addsignkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) {
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
@ -741,7 +755,7 @@ PHP_FUNCTION(gnupg_addsignkey){
gpgme_subkey = gpgme_key->subkeys; gpgme_subkey = gpgme_key->subkeys;
while (gpgme_subkey) { while (gpgme_subkey) {
if (gpgme_subkey->can_sign == 1) { if (gpgme_subkey->can_sign == 1) {
zend_hash_str_add_ptr(PHPC_THIS->signkeys, (char *) gpgme_subkey->keyid, (uint) strlen(gpgme_subkey->keyid), passphrase); PHPC_HASH_CSTR_ADD_PTR(PHPC_THIS->signkeys, gpgme_subkey->keyid, passphrase);
} }
gpgme_subkey = gpgme_subkey->next; gpgme_subkey = gpgme_subkey->next;
} }
@ -756,12 +770,12 @@ PHP_FUNCTION(gnupg_addsignkey){
/* }}} */ /* }}} */
/* {{{ proto bool gnupg_adddecryptkey(string key) */ /* {{{ proto bool gnupg_adddecryptkey(string key) */
PHP_FUNCTION(gnupg_adddecryptkey){ PHP_FUNCTION(gnupg_adddecryptkey)
{
char *key_id = NULL; char *key_id = NULL;
size_t key_id_len; phpc_str_size_t key_id_len;
char *passphrase = NULL; char *passphrase = NULL;
size_t passphrase_len; phpc_str_size_t passphrase_len;
gpgme_key_t gpgme_key; gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey; gpgme_subkey_t gpgme_subkey;
@ -775,7 +789,7 @@ PHP_FUNCTION(gnupg_adddecryptkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR) {
GNUPG_ERR("get_key failed"); GNUPG_ERR("get_key failed");
@ -784,7 +798,7 @@ PHP_FUNCTION(gnupg_adddecryptkey){
gpgme_subkey = gpgme_key->subkeys; gpgme_subkey = gpgme_key->subkeys;
while (gpgme_subkey) { while (gpgme_subkey) {
if (gpgme_subkey->secret == 1) { if (gpgme_subkey->secret == 1) {
zend_hash_str_add_ptr(PHPC_THIS->decryptkeys, (char *) gpgme_subkey->keyid, strlen(gpgme_subkey->keyid), passphrase); PHPC_HASH_CSTR_ADD_PTR(PHPC_THIS->decryptkeys, gpgme_subkey->keyid, passphrase);
} }
gpgme_subkey = gpgme_subkey->next; gpgme_subkey = gpgme_subkey->next;
} }
@ -794,10 +808,10 @@ PHP_FUNCTION(gnupg_adddecryptkey){
/* }}} */ /* }}} */
/* {{{ proto bool gnupg_addencryptkey(string key) */ /* {{{ proto bool gnupg_addencryptkey(string key) */
PHP_FUNCTION(gnupg_addencryptkey){ PHP_FUNCTION(gnupg_addencryptkey)
{
char *key_id = NULL; char *key_id = NULL;
size_t key_id_len; phpc_str_size_t key_id_len;
gpgme_key_t gpgme_key = NULL; gpgme_key_t gpgme_key = NULL;
GNUPG_GETOBJ(); GNUPG_GETOBJ();
@ -810,7 +824,7 @@ PHP_FUNCTION(gnupg_addencryptkey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) {
@ -828,14 +842,15 @@ PHP_FUNCTION(gnupg_addencryptkey){
/* {{{ proto bool gnupg_clearsignerkeys(void) /* {{{ proto bool gnupg_clearsignerkeys(void)
* removes all keys which are set for signing * removes all keys which are set for signing
*/ */
PHP_FUNCTION(gnupg_clearsignkeys){ PHP_FUNCTION(gnupg_clearsignkeys)
{
GNUPG_GETOBJ(); GNUPG_GETOBJ();
if (!this) { if (!this) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
gpgme_signers_clear (PHPC_THIS->ctx); gpgme_signers_clear (PHPC_THIS->ctx);
@ -847,14 +862,15 @@ PHP_FUNCTION(gnupg_clearsignkeys){
/* {{{ proto bool gnupg_clearencryptkeys(void) /* {{{ proto bool gnupg_clearencryptkeys(void)
* removes all keys which are set for encryption * removes all keys which are set for encryption
*/ */
PHP_FUNCTION(gnupg_clearencryptkeys){ PHP_FUNCTION(gnupg_clearencryptkeys)
{
GNUPG_GETOBJ(); GNUPG_GETOBJ();
if (!this) { if (!this) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC); gnupg_free_encryptkeys(PHPC_THIS TSRMLS_CC);
@ -865,14 +881,15 @@ PHP_FUNCTION(gnupg_clearencryptkeys){
/* {{{ proto bool gnupg_clearsignerkeys(void) /* {{{ proto bool gnupg_clearsignerkeys(void)
* removes all keys which are set for signing * removes all keys which are set for signing
*/ */
PHP_FUNCTION(gnupg_cleardecryptkeys){ PHP_FUNCTION(gnupg_cleardecryptkeys)
{
GNUPG_GETOBJ(); GNUPG_GETOBJ();
if (!this) { if (!this) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
zend_hash_clean(PHPC_THIS->decryptkeys); zend_hash_clean(PHPC_THIS->decryptkeys);
@ -885,12 +902,13 @@ PHP_FUNCTION(gnupg_cleardecryptkeys){
* and returns the signed text * and returns the signed text
* the signmode depends on gnupg_setsignmode * the signmode depends on gnupg_setsignmode
*/ */
PHP_FUNCTION(gnupg_sign){ PHP_FUNCTION(gnupg_sign)
{
char *value = NULL; char *value = NULL;
size_t value_len; phpc_str_size_t value_len;
char *userret; char *userret;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t in, out; gpgme_data_t in, out;
gpgme_sign_result_t result; gpgme_sign_result_t result;
@ -905,7 +923,7 @@ PHP_FUNCTION(gnupg_sign){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_cb, PHPC_THIS); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_cb, PHPC_THIS);
@ -956,11 +974,12 @@ PHP_FUNCTION(gnupg_sign){
* encrypts the given text with the key, which was set with setencryptkey before * encrypts the given text with the key, which was set with setencryptkey before
* and returns the encrypted text * and returns the encrypted text
*/ */
PHP_FUNCTION(gnupg_encrypt){ PHP_FUNCTION(gnupg_encrypt)
{
char *value = NULL; char *value = NULL;
size_t value_len; phpc_str_size_t value_len;
char *userret = NULL; char *userret = NULL;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t in, out; gpgme_data_t in, out;
gpgme_encrypt_result_t result; gpgme_encrypt_result_t result;
@ -975,7 +994,7 @@ PHP_FUNCTION(gnupg_encrypt){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if (!PHPC_THIS->encryptkeys) { if (!PHPC_THIS->encryptkeys) {
GNUPG_ERR("no key for encryption set"); GNUPG_ERR("no key for encryption set");
@ -1017,11 +1036,12 @@ PHP_FUNCTION(gnupg_encrypt){
* encrypts and signs the given text with the keys, which weres set with setencryptkey and setsignkey before * encrypts and signs the given text with the keys, which weres set with setencryptkey and setsignkey before
* and returns the encrypted text * and returns the encrypted text
*/ */
PHP_FUNCTION(gnupg_encryptsign){ PHP_FUNCTION(gnupg_encryptsign)
{
char *value = NULL; char *value = NULL;
size_t value_len; phpc_str_size_t value_len;
char *userret = NULL; char *userret = NULL;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t in, out; gpgme_data_t in, out;
gpgme_encrypt_result_t result; gpgme_encrypt_result_t result;
@ -1037,7 +1057,7 @@ PHP_FUNCTION(gnupg_encryptsign){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if (!PHPC_THIS->encryptkeys) { if (!PHPC_THIS->encryptkeys) {
@ -1099,7 +1119,8 @@ PHP_FUNCTION(gnupg_encryptsign){
/* {{{ proto array gnupg_verify(string text, string signature [, string &plaintext]) /* {{{ proto array gnupg_verify(string text, string signature [, string &plaintext])
* verifies the given clearsigned text and returns information about the result in an array * verifies the given clearsigned text and returns information about the result in an array
*/ */
PHP_FUNCTION(gnupg_verify){ PHP_FUNCTION(gnupg_verify)
{
gpgme_data_t gpgme_text, gpgme_sig; gpgme_data_t gpgme_text, gpgme_sig;
gpgme_verify_result_t gpgme_result; gpgme_verify_result_t gpgme_result;
@ -1108,7 +1129,7 @@ PHP_FUNCTION(gnupg_verify){
zval *plain_text = NULL; /* signed_text without the signature if its not a detached sig */ zval *plain_text = NULL; /* signed_text without the signature if its not a detached sig */
char *gpg_plain; char *gpg_plain;
size_t gpg_plain_len; phpc_str_size_t gpg_plain_len;
GNUPG_GETOBJ(); GNUPG_GETOBJ();
@ -1120,7 +1141,7 @@ PHP_FUNCTION(gnupg_verify){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if (Z_TYPE_P(signature) == IS_STRING) { /* detached signature */ if (Z_TYPE_P(signature) == IS_STRING) { /* detached signature */
/* setup signature-databuffer for gpgme */ /* setup signature-databuffer for gpgme */
@ -1184,12 +1205,13 @@ PHP_FUNCTION(gnupg_verify){
/* {{{ proto string gnupg_decrypt(string enctext) /* {{{ proto string gnupg_decrypt(string enctext)
* decrypts the given enctext * decrypts the given enctext
*/ */
PHP_FUNCTION(gnupg_decrypt){ PHP_FUNCTION(gnupg_decrypt)
{
char *enctxt; char *enctxt;
size_t enctxt_len; phpc_str_size_t enctxt_len;
char *userret; char *userret;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t in, out; gpgme_data_t in, out;
gpgme_decrypt_result_t result; gpgme_decrypt_result_t result;
@ -1204,7 +1226,7 @@ PHP_FUNCTION(gnupg_decrypt){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_decrypt_cb, PHPC_THIS); gpgme_set_passphrase_cb (PHPC_THIS->ctx, (void*) passphrase_decrypt_cb, PHPC_THIS);
@ -1246,13 +1268,14 @@ PHP_FUNCTION(gnupg_decrypt){
/* {{{ proto string gnupg_decryptverify(string enctext, string &plaintext) /* {{{ proto string gnupg_decryptverify(string enctext, string &plaintext)
* decrypts the given enctext * decrypts the given enctext
*/ */
PHP_FUNCTION(gnupg_decryptverify){ PHP_FUNCTION(gnupg_decryptverify)
{
char *enctxt; char *enctxt;
size_t enctxt_len; phpc_str_size_t enctxt_len;
zval *plaintext; zval *plaintext;
char *userret; char *userret;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t in, out; gpgme_data_t in, out;
gpgme_decrypt_result_t decrypt_result; gpgme_decrypt_result_t decrypt_result;
@ -1268,7 +1291,7 @@ PHP_FUNCTION(gnupg_decryptverify){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
ZVAL_DEREF(plaintext); ZVAL_DEREF(plaintext);
@ -1314,11 +1337,12 @@ PHP_FUNCTION(gnupg_decryptverify){
/* {{{ proto string gnupg_export(string pattern) /* {{{ proto string gnupg_export(string pattern)
* exports the first public key which matches against the given pattern * exports the first public key which matches against the given pattern
*/ */
PHP_FUNCTION(gnupg_export){ PHP_FUNCTION(gnupg_export)
{
char *searchkey = NULL; char *searchkey = NULL;
size_t searchkey_len; phpc_str_size_t searchkey_len;
char *userret; char *userret;
size_t ret_size; phpc_str_size_t ret_size;
gpgme_data_t out; gpgme_data_t out;
@ -1332,7 +1356,7 @@ PHP_FUNCTION(gnupg_export){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR) {
GNUPG_ERR("could not create data buffer"); GNUPG_ERR("could not create data buffer");
@ -1355,9 +1379,10 @@ PHP_FUNCTION(gnupg_export){
/* {{{ proto array gnupg_import(string key) /* {{{ proto array gnupg_import(string key)
* imports the given key and returns a status-array * imports the given key and returns a status-array
*/ */
PHP_FUNCTION(gnupg_import){ PHP_FUNCTION(gnupg_import)
{
char *importkey = NULL; char *importkey = NULL;
size_t importkey_len; phpc_str_size_t importkey_len;
gpgme_data_t in; gpgme_data_t in;
gpgme_import_result_t result; gpgme_import_result_t result;
@ -1372,7 +1397,7 @@ PHP_FUNCTION(gnupg_import){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_data_new_from_mem (&in, importkey, importkey_len, 0))!=GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_data_new_from_mem (&in, importkey, importkey_len, 0))!=GPG_ERR_NO_ERROR) {
GNUPG_ERR("could not create in-data buffer"); GNUPG_ERR("could not create in-data buffer");
@ -1389,17 +1414,17 @@ PHP_FUNCTION(gnupg_import){
if (!result || !result->imports || result->imports->result != GPG_ERR_NO_ERROR) { if (!result || !result->imports || result->imports->result != GPG_ERR_NO_ERROR) {
RETURN_FALSE; RETURN_FALSE;
} }
array_init (return_value); PHPC_ARRAY_INIT (return_value);
add_assoc_long (return_value, "imported", result->imported); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "imported", result->imported);
add_assoc_long (return_value, "unchanged", result->unchanged); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "unchanged", result->unchanged);
add_assoc_long (return_value, "newuserids", result->new_user_ids); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "newuserids", result->new_user_ids);
add_assoc_long (return_value, "newsubkeys", result->new_sub_keys); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "newsubkeys", result->new_sub_keys);
add_assoc_long (return_value, "secretimported", result->secret_imported); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "secretimported", result->secret_imported);
add_assoc_long (return_value, "secretunchanged", result->secret_unchanged); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "secretunchanged", result->secret_unchanged);
add_assoc_long (return_value, "newsignatures", result->new_signatures); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "newsignatures", result->new_signatures);
add_assoc_long (return_value, "skippedkeys", result->skipped_new_keys); PHPC_ARRAY_ADD_ASSOC_LONG (return_value, "skippedkeys", result->skipped_new_keys);
if (result->imports && result->imports->fpr) { if (result->imports && result->imports->fpr) {
add_assoc_string (return_value, "fingerprint", result->imports->fpr); PHPC_ARRAY_ADD_ASSOC_CSTR (return_value, "fingerprint", result->imports->fpr);
} }
} }
/* }}} */ /* }}} */
@ -1407,9 +1432,10 @@ PHP_FUNCTION(gnupg_import){
/* {{{ proto book gnupg_deletekey(string key) /* {{{ proto book gnupg_deletekey(string key)
* deletes a key from the keyring * deletes a key from the keyring
*/ */
PHP_FUNCTION(gnupg_deletekey){ PHP_FUNCTION(gnupg_deletekey)
{
char *key; char *key;
size_t key_len; phpc_str_size_t key_len;
zend_long allow_secret = 0; zend_long allow_secret = 0;
gpgme_key_t gpgme_key; gpgme_key_t gpgme_key;
@ -1424,7 +1450,7 @@ PHP_FUNCTION(gnupg_deletekey){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_get_key(PHPC_THIS->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR) {
@ -1444,9 +1470,10 @@ PHP_FUNCTION(gnupg_deletekey){
/* {{{ proto array gnupg_gettrustlist(string pattern) /* {{{ proto array gnupg_gettrustlist(string pattern)
* searching for trust items which match PATTERN * searching for trust items which match PATTERN
*/ */
PHP_FUNCTION(gnupg_gettrustlist){ PHP_FUNCTION(gnupg_gettrustlist)
{
char *pattern; char *pattern;
size_t pattern_len; phpc_str_size_t pattern_len;
zval sub_arr; zval sub_arr;
gpgme_trust_item_t item; gpgme_trust_item_t item;
@ -1461,32 +1488,33 @@ PHP_FUNCTION(gnupg_gettrustlist){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_op_trustlist_start (PHPC_THIS->ctx, pattern, 0))!=GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_op_trustlist_start (PHPC_THIS->ctx, pattern, 0))!=GPG_ERR_NO_ERROR) {
GNUPG_ERR("could not start trustlist"); GNUPG_ERR("could not start trustlist");
return; return;
} }
array_init(return_value); PHPC_ARRAY_INIT(return_value);
while (!(PHPC_THIS->err = gpgme_op_trustlist_next (PHPC_THIS->ctx, &item))) { while (!(PHPC_THIS->err = gpgme_op_trustlist_next (PHPC_THIS->ctx, &item))) {
array_init (&sub_arr); PHPC_ARRAY_INIT (&sub_arr);
add_assoc_long (&sub_arr, "level", item->level ); PHPC_ARRAY_ADD_ASSOC_LONG (&sub_arr, "level", item->level );
add_assoc_long (&sub_arr, "type", item->type ); PHPC_ARRAY_ADD_ASSOC_LONG (&sub_arr, "type", item->type );
add_assoc_string (&sub_arr, "keyid", item->keyid ); PHPC_ARRAY_ADD_ASSOC_CSTR (&sub_arr, "keyid", item->keyid );
add_assoc_string (&sub_arr, "ownertrust", item->owner_trust ); PHPC_ARRAY_ADD_ASSOC_CSTR (&sub_arr, "ownertrust", item->owner_trust );
add_assoc_string (&sub_arr, "validity", item->validity ); PHPC_ARRAY_ADD_ASSOC_CSTR (&sub_arr, "validity", item->validity );
add_assoc_string (&sub_arr, "name", item->name ); PHPC_ARRAY_ADD_ASSOC_CSTR (&sub_arr, "name", item->name );
gpgme_trust_item_unref (item); gpgme_trust_item_unref (item);
add_next_index_zval (return_value, &sub_arr); PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL (return_value, &sub_arr);
} }
} }
/* }}} */ /* }}} */
/* {{{ proto array gnupg_listsignatures(string keyid) */ /* {{{ proto array gnupg_listsignatures(string keyid) */
PHP_FUNCTION(gnupg_listsignatures){ PHP_FUNCTION(gnupg_listsignatures)
{
char *keyid; char *keyid;
size_t keyid_len; phpc_str_size_t keyid_len;
zval sub_arr; zval sub_arr;
zval sig_arr; zval sig_arr;
@ -1505,7 +1533,7 @@ PHP_FUNCTION(gnupg_listsignatures){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE) {
return; return;
} }
PHPC_THIS = (gnupg_object *) zend_fetch_resource(Z_RES_P(res), "ctx", le_gnupg); GNUPG_RES_FETCH();
} }
if ((PHPC_THIS->err = gpgme_set_keylist_mode(PHPC_THIS->ctx,GPGME_KEYLIST_MODE_SIGS))!=GPG_ERR_NO_ERROR) { if ((PHPC_THIS->err = gpgme_set_keylist_mode(PHPC_THIS->ctx,GPGME_KEYLIST_MODE_SIGS))!=GPG_ERR_NO_ERROR) {
GNUPG_ERR("could not switch to sigmode"); GNUPG_ERR("could not switch to sigmode");
@ -1520,22 +1548,22 @@ PHP_FUNCTION(gnupg_listsignatures){
gpgme_key_unref(gpgme_key); gpgme_key_unref(gpgme_key);
return; return;
} }
array_init(return_value); PHPC_ARRAY_INIT(return_value);
gpgme_userid = gpgme_key->uids; gpgme_userid = gpgme_key->uids;
while (gpgme_userid) { while (gpgme_userid) {
array_init (&sub_arr); PHPC_ARRAY_INIT (&sub_arr);
gpgme_signature = gpgme_userid->signatures; gpgme_signature = gpgme_userid->signatures;
while (gpgme_signature) { while (gpgme_signature) {
array_init (&sig_arr); PHPC_ARRAY_INIT (&sig_arr);
add_assoc_string (&sig_arr, "uid", gpgme_signature->uid ); PHPC_ARRAY_ADD_ASSOC_CSTR (&sig_arr, "uid", gpgme_signature->uid );
add_assoc_string (&sig_arr, "name", gpgme_signature->name ); PHPC_ARRAY_ADD_ASSOC_CSTR(&sig_arr, "name", gpgme_signature->name );
add_assoc_string (&sig_arr, "email", gpgme_signature->email ); PHPC_ARRAY_ADD_ASSOC_CSTR(&sig_arr, "email", gpgme_signature->email );
add_assoc_string (&sig_arr, "comment", gpgme_signature->comment ); PHPC_ARRAY_ADD_ASSOC_CSTR(&sig_arr, "comment", gpgme_signature->comment );
add_assoc_long (&sig_arr, "expires", gpgme_signature->expires ); PHPC_ARRAY_ADD_ASSOC_LONG (&sig_arr, "expires", gpgme_signature->expires );
add_assoc_bool (&sig_arr, "revoked", gpgme_signature->revoked ); PHPC_ARRAY_ADD_ASSOC_BOOL (&sig_arr, "revoked", gpgme_signature->revoked );
add_assoc_bool (&sig_arr, "expired", gpgme_signature->expired ); PHPC_ARRAY_ADD_ASSOC_BOOL (&sig_arr, "expired", gpgme_signature->expired );
add_assoc_bool (&sig_arr, "invalid", gpgme_signature->invalid ); PHPC_ARRAY_ADD_ASSOC_BOOL (&sig_arr, "invalid", gpgme_signature->invalid );
add_assoc_zval (&sub_arr, gpgme_signature->keyid, &sig_arr); add_assoc_zval (&sub_arr, gpgme_signature->keyid, &sig_arr);
gpgme_signature = gpgme_signature->next; gpgme_signature = gpgme_signature->next;
} }

2
phpc

@ -1 +1 @@
Subproject commit 28b8bdf2a78a31772a325099806eb984ac9063ea Subproject commit 11299415b61f6c90f26410517e0c673b47efb7d8