trunk/MyGPGME/encrypt.c

/* encrypt.c -  Encrypt functions
 *      Copyright (C) 2000, 2001 Werner Koch (dd9jn), g10 Code GmbH
 *      Copyright (C) 2002-2005 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MyGPGME is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "util.h"
#include "context.h"
#include "ops.h"


#define use_symmetric(rset) (!(rset) || !gpgme_recipients_count ((rset)))

struct recp_info_s {
    struct recp_info_s * next;
    gpgme_error_t code;
    char recp[1];
};

struct encrypt_result_s {
    int okay;
    int no_recp;
    int inv_recp;
    int file_start;
    int file_done;
    struct recp_info_s * inf;
};


static gpgme_error_t
create_result_struct( gpgme_ctx_t ctx )
{
    assert ( !ctx->result.encrypt );
    ctx->result.encrypt = calloc( 1, sizeof *ctx->result.encrypt );
    if( !ctx->result.encrypt )
        return mk_error( Out_Of_Core );
    ctx->result_type = RESULT_TYPE_ENCRYPT;
    return 0;
} /* create_result_struct */


static gpgme_error_t
add_recp_info( _encrypt_result_t res, int code, const char * name )
{
    struct recp_info_s * r;

    r = calloc( 1, sizeof * r + strlen( name ) + 1 );
    if( !r )
        return mk_error( Out_Of_Core );
    r->code = code;
    strcpy (r->recp , name);
    r->next = res->inf;
    res->inf = r;

    return 0;
} /* add_recp_info */


void
_gpgme_release_encrypt_result( _encrypt_result_t res )
{    
    struct recp_info_s * r, * r2;

    if( !res )
        return;
    r = res->inf;
    while( r ) {
        r2 = r->next;
        safe_free( r );
        r = r2;
    }
    safe_free( res->inf );
    safe_free( res );
} /* _gpgme_release_encrypt_result */


void
_gpgme_encrypt_add_cipher (gpgme_ctx_t ctx)
{
    if (ctx->cipher_algo == -1)
        return;
    _gpgme_gpg_add_arg (ctx->gpg, "--cipher-algo");
    switch (ctx->cipher_algo) {
    case GPGME_CIPHER_3DES:     _gpgme_gpg_add_arg (ctx->gpg, "3DES");break;
    case GPGME_CIPHER_CAST5:    _gpgme_gpg_add_arg (ctx->gpg, "CAST5");break;
    case GPGME_CIPHER_BLOWFISH: _gpgme_gpg_add_arg (ctx->gpg, "BLOWFISH");break;
    case GPGME_CIPHER_AES128:   _gpgme_gpg_add_arg (ctx->gpg, "AES");break;
    case GPGME_CIPHER_AES192:   _gpgme_gpg_add_arg (ctx->gpg, "AES192");break;
    case GPGME_CIPHER_AES256:   _gpgme_gpg_add_arg (ctx->gpg, "AES256");break;
    case GPGME_CIPHER_TWOFISH:  _gpgme_gpg_add_arg (ctx->gpg, "TWOFISH");break; 
    default:                    _gpgme_gpg_add_arg (ctx->gpg, "AES");break;
    }
    if (ctx->s2k.used) {
        char buf[32];
        if (ctx->s2k.mode < 0 || ctx->s2k.mode > 3)
            ctx->s2k.mode = GPGME_S2K_ITERSALTED;
        sprintf( buf, "%d", ctx->s2k.mode );
        _gpgme_gpg_add_arg (ctx->gpg, "--s2k-mode");
        _gpgme_gpg_add_arg (ctx->gpg,  buf);
        _gpgme_gpg_add_arg (ctx->gpg, "--s2k-digest-algo");
        switch (ctx->s2k.digest_algo) {
        case GPGME_MD_SHA1:  _gpgme_gpg_add_arg (ctx->gpg, "SHA1"); break;
        case GPGME_MD_RMD160:_gpgme_gpg_add_arg (ctx->gpg, "RIPEMD160"); break;
        default:             _gpgme_gpg_add_arg (ctx->gpg, "SHA1"); break;
        }
    }
} /* _gpgme_encrypt_add_cipher */


static void
encrypt_status_handler( gpgme_ctx_t ctx, gpg_statcode_t code, char * args )
{
    int i = 0;
    gpgme_error_t err;

    if (ctx->out_of_core)
        return;
    
    if( ctx->result_type == RESULT_TYPE_NONE ) {
        if( create_result_struct ( ctx ) ) {
            ctx->out_of_core = 1;
            return;
        }
    }
    assert( ctx->result_type == RESULT_TYPE_ENCRYPT );
    
    switch( code ) {
    case STATUS_END_ENCRYPTION:
        ctx->result.encrypt->okay = 1;
        break;

    case STATUS_NO_RECP:
        ctx->result.encrypt->no_recp = 1;
        break;
        
    case STATUS_INV_RECP:
        while( args[i] && args[i] != ' ' )
            i++;
        while( args[i] && args[i] != ' ' )
            i++;
        err = add_recp_info( ctx->result.encrypt, atol( args ), args + i );
        if( err )
            ctx->out_of_core = 1;
        ctx->result.encrypt->inv_recp++;
        break;

    case STATUS_FILE_START:
        ctx->result.encrypt->file_start++;
        if( ctx->cb.interactiv )
            ctx->cb.interactiv( ctx->cb.interactiv_value, code, NULL, args+2 );
        break;

    case STATUS_FILE_DONE:
        ctx->result.encrypt->file_done++;
        if( ctx->cb.interactiv )
            ctx->cb.interactiv( ctx->cb.interactiv_value, code, NULL, NULL );
        break;

    case STATUS_PROGRESS:
        if (ctx->cb.progress)
            _gpgme_progress_handler (ctx, args);
        break;
    }
} /* encrypt_status_handler */


static const char *
encrypt_command_handler (void * opaque, gpg_statcode_t code, const char * key)
{
    gpgme_ctx_t ctx = opaque;

    if (!ctx)
        return NULL;
    if (!strcmp (key, "untrusted_key.override"))
        return "N";
    if (!ctx->cb.interactiv)
        return NULL;
    if ((code == STATUS_GET_BOOL && !strcmp (key, "openfile.overwrite.okay"))
      ||(code == STATUS_GET_LINE && !strcmp (key, "openfile.askoutname" )) )
        return ctx->cb.interactiv (ctx->cb.interactiv_value, code, key, NULL);

    return NULL;
} /* encrypt_command_handler */


static gpgme_error_t
encrypt_start( gpgme_ctx_t ctx, gpgme_recipients_t recp, 
               gpgme_data_t plain, gpgme_data_t ciph )
              
{
    gpgme_error_t rc = 0;
    
    fail_on_pending_request (ctx);
    ctx->pending = 1;
    
    /* do some checks */    
    if( !gpgme_recipients_count ( recp ) ) {
        rc = mk_error( No_Recipients );
        goto leave;
    }
    
    /* create a process object */
    _gpgme_gpg_release (&ctx->gpg);
    rc = _gpgme_gpg_new (&ctx->gpg);
    if (rc)
        goto leave;
    
    _gpgme_gpg_set_status_handler (ctx->gpg, encrypt_status_handler, ctx);
    _gpgme_gpg_set_command_handler (ctx->gpg, encrypt_command_handler, ctx);
    
    /* build the commandline */
    _gpgme_gpg_add_arg( ctx->gpg, "--encrypt" );
    if( ctx->use_armor )
        _gpgme_gpg_add_arg( ctx->gpg, "--armor" );
    if (ctx->no_compress)
        _gpgme_gpg_add_arg (ctx->gpg, "-z 0");
    if (ctx->force_mdc)
        _gpgme_gpg_add_arg (ctx->gpg, "--force-mdc");
    _gpgme_add_comment (ctx);
    if (ctx->cb.progress)
        _gpgme_gpg_add_arg (ctx->gpg, "--enable-progress-filter");
    /* If we know that all recipients are valid (full or ultimate trust)
       we can pass suppress further checks */
    if( ctx->force_trust || _gpgme_recipients_all_valid( recp ) )
        _gpgme_gpg_add_arg( ctx->gpg, "--always-trust" );
    
    _gpgme_append_gpg_args_from_recipients( recp, ctx->gpg );
    if (ctx->use_logging)
        _gpgme_gpg_set_logging_handler (ctx->gpg, ctx);
    
    /* Check the supplied data */
    if( gpgme_data_get_type( plain ) == GPGME_DATA_TYPE_NONE ) {
        rc = mk_error( No_Data );
        goto leave;
    }
    _gpgme_data_set_mode( plain, GPGME_DATA_MODE_OUT );
    if( !ciph || gpgme_data_get_type( ciph ) != GPGME_DATA_TYPE_NONE ) {
        rc = mk_error( Invalid_Value );
        goto leave;
    }
    _gpgme_data_set_mode( ciph, GPGME_DATA_MODE_IN );
    /* Tell the gpg object about the data */
    if( ctx->use_tmpfiles ) {
        _gpgme_gpg_add_arg( ctx->gpg, "--yes" );
        _gpgme_gpg_add_arg( ctx->gpg, "--output" );
        _gpgme_gpg_add_arg( ctx->gpg, _gpgme_get_tmpfile( 0 ) );
        _gpgme_data_write_to_tmpfile( plain );
        _gpgme_gpg_add_arg( ctx->gpg, _gpgme_get_tmpfile( 1 ) );
    }
    else {
        _gpgme_gpg_add_arg( ctx->gpg, "--output" );
        _gpgme_gpg_add_arg( ctx->gpg, "-" );
        _gpgme_gpg_add_data( ctx->gpg, ciph, 1 );
        _gpgme_gpg_add_arg( ctx->gpg, "--" );
        _gpgme_gpg_add_data( ctx->gpg, plain, 0 );
    }
    
    /* and kick off the process */
    rc = _gpgme_gpg_spawn ( ctx->gpg, ctx );
    
leave:
    if( rc ) {
        ctx->pending = 0; 
        _gpgme_gpg_release( &ctx->gpg );
    }

    return rc;
} /* encrypt_start */


gpgme_error_t
file_encrypt_start( gpgme_ctx_t ctx, gpgme_recipients_t recp,
                    const char ** input, size_t nfiles, const char * output )
{
    gpgme_error_t rc = 0;
    int symmetric = 0;
    
    if( !input )
        return mk_error( Invalid_Value );

    fail_on_pending_request( ctx );
    ctx->pending = 1;
    
    if( use_symmetric( recp ) )
        symmetric = 1;
    
    _gpgme_gpg_release( &ctx->gpg );
    rc = _gpgme_gpg_new( &ctx->gpg );
    if( rc ) {
        gpgme_release( ctx );
        return rc;
    }
        
    _gpgme_gpg_set_status_handler( ctx->gpg, encrypt_status_handler, ctx );
    if( ctx->cb.interactiv )
        _gpgme_gpg_set_command_handler( ctx->gpg, encrypt_command_handler, ctx );
    else
        _gpgme_gpg_add_arg (ctx->gpg, "--yes");
    if( ctx->use_armor )
        _gpgme_gpg_add_arg (ctx->gpg, "--armor");
    if (ctx->no_compress)
        _gpgme_gpg_add_arg (ctx->gpg, "-z 0");
    if (ctx->force_mdc)
        _gpgme_gpg_add_arg (ctx->gpg, "--force-mdc");
    _gpgme_add_comment (ctx);
    if( ctx->cb.progress )
        _gpgme_gpg_add_arg( ctx->gpg, "--enable-progress-filter" );
    if( !output )
        _gpgme_gpg_add_arg( ctx->gpg, "--no-mangle-dos-filenames" );

    if( symmetric ) {
        _gpgme_gpg_add_arg( ctx->gpg, "--symmetric" );
        _gpgme_encrypt_add_cipher( ctx );
        rc = _gpgme_add_passphrase( ctx );
        if( rc ) {
            _gpgme_gpg_release( &ctx->gpg );
            return rc;
        }
    }
    else {
        if( ctx->use_throwkeyid )
            _gpgme_gpg_add_arg( ctx->gpg, "--throw-keyid" );
        if( ctx->force_trust )
            _gpgme_gpg_add_arg( ctx->gpg, "--always-trust" );
        if( recp )
            _gpgme_append_gpg_args_from_recipients( recp, ctx->gpg );
        if( ctx->pipemode || nfiles > 1 )
            _gpgme_gpg_add_arg( ctx->gpg, "--encrypt-files" );
        else
            _gpgme_gpg_add_arg( ctx->gpg, "--encrypt" );
            
    }
    
    /* we cannot use --output for --encrypt-files */
    if( nfiles == 1  && !ctx->pipemode && output ) {
        _gpgme_gpg_add_arg( ctx->gpg, "--output" );
        _gpgme_gpg_add_arg( ctx->gpg, output );
    }
    while( nfiles-- )
        _gpgme_gpg_add_arg( ctx->gpg, *input++ );
    rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
    if( rc ) {
        ctx->pending = 0;
        _gpgme_gpg_release( &ctx->gpg );
    }
    
    return rc;
} /* file_encrypt_start */


static gpgme_error_t
get_encrypt_result (gpgme_ctx_t ctx)
{
    struct encrypt_result_s * res;
    gpgme_error_t err = 0;
    int rc;

    assert (ctx->result.encrypt);
    res = ctx->result.encrypt;
    if (res->okay)
        return mk_error( No_Error );
    if (res->no_recp)
        err = mk_error (No_Recipients);
    else if (res->inv_recp)
        err = mk_error (Inv_Recipients);
    else if ((rc = gpgme_get_process_rc (ctx )) != 0) {
        DEBUG1 ("gpg return code=%d\n", rc);
        err = mk_error (Internal_GPG_Problem);
    }
    else if (!res->okay || (res->file_start != res->file_done))
        err = mk_error (Encryption_Failed);
    return err;
} /* get_encrypt_result */


/**
 * gpgme_op_encrypt:
 * @ctx: The context
 * @recp: A set of recipients 
 * @in: plaintext input
 * @out: ciphertext output
 * 
 * This function encrypts @in to @out for all recipients from
 * @recp.  Other parameters are take from the context @c.
 * The function does wait for the result.
 * 
 * Return value:  0 on success or an errorcode. 
 **/
gpgme_error_t
gpgme_op_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t recp, 
                  gpgme_data_t in, gpgme_data_t out )
                  
{
    gpgme_error_t err;
    
    err = encrypt_start( ctx, recp, in, out );
    if( !err ) {
        gpgme_wait( ctx, 1 );
        ctx->pending = 0;
        if( ctx->use_tmpfiles ) {
            _gpgme_data_read_from_tmpfile( out );
            _gpgme_del_tmpfiles( ctx->wipe_fnc );
        }
        err = get_encrypt_result( ctx );
    }

    return err;
} /* gpgme_op_encrypt */


gpgme_error_t
gpgme_op_file_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t rset, 
                       const char * input, const char * output )
{       
    gpgme_error_t err;
    const char * files[1];

    files[0] = input;
    err = file_encrypt_start( ctx, rset, files, 1, output );
    if( !err ) {
        gpgme_wait( ctx, 1 );
        ctx->pending = 0;
        err = get_encrypt_result( ctx );
    } 
    
    return err;
} /* gpgme_op_file_encrypt */


gpgme_error_t
gpgme_op_files_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t rset,
                        const char ** files, size_t nfiles )
{
    gpgme_error_t err;

    /* fixme: the result is actually only for the last file. we need
              a notification system which informs us with a callback
              after each file is processed. */
    if( use_symmetric( rset ) ) {
        const char * s[1];
        size_t i;

        for( i=0; i < nfiles; i++ ) {
            s[0] = files[i];
            err = file_encrypt_start( ctx, NULL, s, 1, NULL );
            if( !err ) {
                gpgme_wait( ctx, 1 );
                ctx->pending = 0;
                err = get_encrypt_result( ctx );
            }
            if( err )
                break;
        }
    }
    else {
        err = file_encrypt_start( ctx, rset, files, nfiles, NULL );
        if( !err ) {
            gpgme_wait( ctx, 1 );
            ctx->pending = 0;
            err = get_encrypt_result( ctx );
        }
    }
    return err;
}


gpgme_error_t
gpgme_op_clip_encrypt( gpgme_recipients_t rset, int opts, gpgme_ctx_t *r_ctx )
{
    gpgme_error_t err;
    gpgme_ctx_t ctx = NULL;
    gpgme_data_t plain = NULL;
    gpgme_data_t ciph = NULL;
    
    err = gpgme_new( &ctx );
    if( err )
        return err;
    
    if( opts & GPGME_CTRL_TMPFILES )
        gpgme_control( ctx, GPGME_CTRL_TMPFILES, 1 );
    if( opts & GPGME_CTRL_FORCETRUST )
        gpgme_control( ctx, GPGME_CTRL_FORCETRUST, 1 );
    gpgme_control( ctx, GPGME_CTRL_ARMOR, 1 );  
    
    err = gpgme_data_new_from_clipboard (&plain);
    if( !err )
        err = gpgme_data_new( &ciph );
    if( !err )
        err = gpgme_op_encrypt( ctx, rset, plain, ciph );
    if( !err ) {
        gpgme_data_change_version( &ciph );
        gpgme_data_release_and_set_clipboard( ciph );
    }
    if( r_ctx )
        *r_ctx = ctx;
    else
        gpgme_release( ctx );
    gpgme_data_release( plain );
    return err;
} /* gpgme_op_clip_encrypt */


int
gpgme_recperr_count_items( gpgme_ctx_t ctx )
{
    struct recp_info_s * r;
    int ncount = 0;

    if( !ctx )
        return 0;
    if( ctx->result_type != RESULT_TYPE_ENCRYPT )
        return -1;
    for( r = ctx->result.encrypt->inf; r; r = r->next )
        ncount++;

    return ncount;
} /* gpgme_recperr_count_items */


const char*
gpgme_recperr_get( gpgme_ctx_t ctx, int idx, gpgme_error_t *r_code )
{
    struct recp_info_s * r;

    if( !ctx )
        return NULL;
    if( idx > gpgme_recperr_count_items( ctx ) )
        return NULL;
    for( r = ctx->result.encrypt->inf; r && idx--; r = r->next )
        ;
    if( r ) {
        if( r_code )
            *r_code = r->code;
        return r->recp;
    }

    return NULL;
} /* gpgme_recperr_get_code */
1	/* encrypt.c - Encrypt functions
2	* Copyright (C) 2000, 2001 Werner Koch (dd9jn), g10 Code GmbH
3	* Copyright (C) 2002-2005 Timo Schulz
4	*
5	* This file is part of MyGPGME.
6	*
7	* MyGPGME is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* MyGPGME is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software Foundation,
19	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20	*/
21
22	#include <stdio.h>
23	#include <stdlib.h>
24	#include <string.h>
25	#include <assert.h>
26
27	#include "util.h"
28	#include "context.h"
29	#include "ops.h"
30
31
32	#define use_symmetric(rset) (!(rset) \|\| !gpgme_recipients_count ((rset)))
33
34	struct recp_info_s {
35	struct recp_info_s * next;
36	gpgme_error_t code;
37	char recp[1];
38	};
39
40	struct encrypt_result_s {
41	int okay;
42	int no_recp;
43	int inv_recp;
44	int file_start;
45	int file_done;
46	struct recp_info_s * inf;
47	};
48
49
50	static gpgme_error_t
51	create_result_struct( gpgme_ctx_t ctx )
52	{
53	assert ( !ctx->result.encrypt );
54	ctx->result.encrypt = calloc( 1, sizeof *ctx->result.encrypt );
55	if( !ctx->result.encrypt )
56	return mk_error( Out_Of_Core );
57	ctx->result_type = RESULT_TYPE_ENCRYPT;
58	return 0;
59	} /* create_result_struct */
60
61
62	static gpgme_error_t
63	add_recp_info( _encrypt_result_t res, int code, const char * name )
64	{
65	struct recp_info_s * r;
66
67	r = calloc( 1, sizeof * r + strlen( name ) + 1 );
68	if( !r )
69	return mk_error( Out_Of_Core );
70	r->code = code;
71	strcpy (r->recp , name);
72	r->next = res->inf;
73	res->inf = r;
74
75	return 0;
76	} /* add_recp_info */
77
78
79	void
80	_gpgme_release_encrypt_result( _encrypt_result_t res )
81	{
82	struct recp_info_s * r, * r2;
83
84	if( !res )
85	return;
86	r = res->inf;
87	while( r ) {
88	r2 = r->next;
89	safe_free( r );
90	r = r2;
91	}
92	safe_free( res->inf );
93	safe_free( res );
94	} /* _gpgme_release_encrypt_result */
95
96
97	void
98	_gpgme_encrypt_add_cipher (gpgme_ctx_t ctx)
99	{
100	if (ctx->cipher_algo == -1)
101	return;
102	_gpgme_gpg_add_arg (ctx->gpg, "--cipher-algo");
103	switch (ctx->cipher_algo) {
104	case GPGME_CIPHER_3DES: _gpgme_gpg_add_arg (ctx->gpg, "3DES");break;
105	case GPGME_CIPHER_CAST5: _gpgme_gpg_add_arg (ctx->gpg, "CAST5");break;
106	case GPGME_CIPHER_BLOWFISH: _gpgme_gpg_add_arg (ctx->gpg, "BLOWFISH");break;
107	case GPGME_CIPHER_AES128: _gpgme_gpg_add_arg (ctx->gpg, "AES");break;
108	case GPGME_CIPHER_AES192: _gpgme_gpg_add_arg (ctx->gpg, "AES192");break;
109	case GPGME_CIPHER_AES256: _gpgme_gpg_add_arg (ctx->gpg, "AES256");break;
110	case GPGME_CIPHER_TWOFISH: _gpgme_gpg_add_arg (ctx->gpg, "TWOFISH");break;
111	default: _gpgme_gpg_add_arg (ctx->gpg, "AES");break;
112	}
113	if (ctx->s2k.used) {
114	char buf[32];
115	if (ctx->s2k.mode < 0 \|\| ctx->s2k.mode > 3)
116	ctx->s2k.mode = GPGME_S2K_ITERSALTED;
117	sprintf( buf, "%d", ctx->s2k.mode );
118	_gpgme_gpg_add_arg (ctx->gpg, "--s2k-mode");
119	_gpgme_gpg_add_arg (ctx->gpg, buf);
120	_gpgme_gpg_add_arg (ctx->gpg, "--s2k-digest-algo");
121	switch (ctx->s2k.digest_algo) {
122	case GPGME_MD_SHA1: _gpgme_gpg_add_arg (ctx->gpg, "SHA1"); break;
123	case GPGME_MD_RMD160:_gpgme_gpg_add_arg (ctx->gpg, "RIPEMD160"); break;
124	default: _gpgme_gpg_add_arg (ctx->gpg, "SHA1"); break;
125	}
126	}
127	} /* _gpgme_encrypt_add_cipher */
128
129
130	static void
131	encrypt_status_handler( gpgme_ctx_t ctx, gpg_statcode_t code, char * args )
132	{
133	int i = 0;
134	gpgme_error_t err;
135
136	if (ctx->out_of_core)
137	return;
138
139	if( ctx->result_type == RESULT_TYPE_NONE ) {
140	if( create_result_struct ( ctx ) ) {
141	ctx->out_of_core = 1;
142	return;
143	}
144	}
145	assert( ctx->result_type == RESULT_TYPE_ENCRYPT );
146
147	switch( code ) {
148	case STATUS_END_ENCRYPTION:
149	ctx->result.encrypt->okay = 1;
150	break;
151
152	case STATUS_NO_RECP:
153	ctx->result.encrypt->no_recp = 1;
154	break;
155
156	case STATUS_INV_RECP:
157	while( args[i] && args[i] != ' ' )
158	i++;
159	while( args[i] && args[i] != ' ' )
160	i++;
161	err = add_recp_info( ctx->result.encrypt, atol( args ), args + i );
162	if( err )
163	ctx->out_of_core = 1;
164	ctx->result.encrypt->inv_recp++;
165	break;
166
167	case STATUS_FILE_START:
168	ctx->result.encrypt->file_start++;
169	if( ctx->cb.interactiv )
170	ctx->cb.interactiv( ctx->cb.interactiv_value, code, NULL, args+2 );
171	break;
172
173	case STATUS_FILE_DONE:
174	ctx->result.encrypt->file_done++;
175	if( ctx->cb.interactiv )
176	ctx->cb.interactiv( ctx->cb.interactiv_value, code, NULL, NULL );
177	break;
178
179	case STATUS_PROGRESS:
180	if (ctx->cb.progress)
181	_gpgme_progress_handler (ctx, args);
182	break;
183	}
184	} /* encrypt_status_handler */
185
186
187	static const char *
188	encrypt_command_handler (void * opaque, gpg_statcode_t code, const char * key)
189	{
190	gpgme_ctx_t ctx = opaque;
191
192	if (!ctx)
193	return NULL;
194	if (!strcmp (key, "untrusted_key.override"))
195	return "N";
196	if (!ctx->cb.interactiv)
197	return NULL;
198	if ((code == STATUS_GET_BOOL && !strcmp (key, "openfile.overwrite.okay"))
199	\|\|(code == STATUS_GET_LINE && !strcmp (key, "openfile.askoutname" )) )
200	return ctx->cb.interactiv (ctx->cb.interactiv_value, code, key, NULL);
201
202	return NULL;
203	} /* encrypt_command_handler */
204
205
206	static gpgme_error_t
207	encrypt_start( gpgme_ctx_t ctx, gpgme_recipients_t recp,
208	gpgme_data_t plain, gpgme_data_t ciph )
209
210	{
211	gpgme_error_t rc = 0;
212
213	fail_on_pending_request (ctx);
214	ctx->pending = 1;
215
216	/* do some checks */
217	if( !gpgme_recipients_count ( recp ) ) {
218	rc = mk_error( No_Recipients );
219	goto leave;
220	}
221
222	/* create a process object */
223	_gpgme_gpg_release (&ctx->gpg);
224	rc = _gpgme_gpg_new (&ctx->gpg);
225	if (rc)
226	goto leave;
227
228	_gpgme_gpg_set_status_handler (ctx->gpg, encrypt_status_handler, ctx);
229	_gpgme_gpg_set_command_handler (ctx->gpg, encrypt_command_handler, ctx);
230
231	/* build the commandline */
232	_gpgme_gpg_add_arg( ctx->gpg, "--encrypt" );
233	if( ctx->use_armor )
234	_gpgme_gpg_add_arg( ctx->gpg, "--armor" );
235	if (ctx->no_compress)
236	_gpgme_gpg_add_arg (ctx->gpg, "-z 0");
237	if (ctx->force_mdc)
238	_gpgme_gpg_add_arg (ctx->gpg, "--force-mdc");
239	_gpgme_add_comment (ctx);
240	if (ctx->cb.progress)
241	_gpgme_gpg_add_arg (ctx->gpg, "--enable-progress-filter");
242	/* If we know that all recipients are valid (full or ultimate trust)
243	we can pass suppress further checks */
244	if( ctx->force_trust \|\| _gpgme_recipients_all_valid( recp ) )
245	_gpgme_gpg_add_arg( ctx->gpg, "--always-trust" );
246
247	_gpgme_append_gpg_args_from_recipients( recp, ctx->gpg );
248	if (ctx->use_logging)
249	_gpgme_gpg_set_logging_handler (ctx->gpg, ctx);
250
251	/* Check the supplied data */
252	if( gpgme_data_get_type( plain ) == GPGME_DATA_TYPE_NONE ) {
253	rc = mk_error( No_Data );
254	goto leave;
255	}
256	_gpgme_data_set_mode( plain, GPGME_DATA_MODE_OUT );
257	if( !ciph \|\| gpgme_data_get_type( ciph ) != GPGME_DATA_TYPE_NONE ) {
258	rc = mk_error( Invalid_Value );
259	goto leave;
260	}
261	_gpgme_data_set_mode( ciph, GPGME_DATA_MODE_IN );
262	/* Tell the gpg object about the data */
263	if( ctx->use_tmpfiles ) {
264	_gpgme_gpg_add_arg( ctx->gpg, "--yes" );
265	_gpgme_gpg_add_arg( ctx->gpg, "--output" );
266	_gpgme_gpg_add_arg( ctx->gpg, _gpgme_get_tmpfile( 0 ) );
267	_gpgme_data_write_to_tmpfile( plain );
268	_gpgme_gpg_add_arg( ctx->gpg, _gpgme_get_tmpfile( 1 ) );
269	}
270	else {
271	_gpgme_gpg_add_arg( ctx->gpg, "--output" );
272	_gpgme_gpg_add_arg( ctx->gpg, "-" );
273	_gpgme_gpg_add_data( ctx->gpg, ciph, 1 );
274	_gpgme_gpg_add_arg( ctx->gpg, "--" );
275	_gpgme_gpg_add_data( ctx->gpg, plain, 0 );
276	}
277
278	/* and kick off the process */
279	rc = _gpgme_gpg_spawn ( ctx->gpg, ctx );
280
281	leave:
282	if( rc ) {
283	ctx->pending = 0;
284	_gpgme_gpg_release( &ctx->gpg );
285	}
286
287	return rc;
288	} /* encrypt_start */
289
290
291	gpgme_error_t
292	file_encrypt_start( gpgme_ctx_t ctx, gpgme_recipients_t recp,
293	const char ** input, size_t nfiles, const char * output )
294	{
295	gpgme_error_t rc = 0;
296	int symmetric = 0;
297
298	if( !input )
299	return mk_error( Invalid_Value );
300
301	fail_on_pending_request( ctx );
302	ctx->pending = 1;
303
304	if( use_symmetric( recp ) )
305	symmetric = 1;
306
307	_gpgme_gpg_release( &ctx->gpg );
308	rc = _gpgme_gpg_new( &ctx->gpg );
309	if( rc ) {
310	gpgme_release( ctx );
311	return rc;
312	}
313
314	_gpgme_gpg_set_status_handler( ctx->gpg, encrypt_status_handler, ctx );
315	if( ctx->cb.interactiv )
316	_gpgme_gpg_set_command_handler( ctx->gpg, encrypt_command_handler, ctx );
317	else
318	_gpgme_gpg_add_arg (ctx->gpg, "--yes");
319	if( ctx->use_armor )
320	_gpgme_gpg_add_arg (ctx->gpg, "--armor");
321	if (ctx->no_compress)
322	_gpgme_gpg_add_arg (ctx->gpg, "-z 0");
323	if (ctx->force_mdc)
324	_gpgme_gpg_add_arg (ctx->gpg, "--force-mdc");
325	_gpgme_add_comment (ctx);
326	if( ctx->cb.progress )
327	_gpgme_gpg_add_arg( ctx->gpg, "--enable-progress-filter" );
328	if( !output )
329	_gpgme_gpg_add_arg( ctx->gpg, "--no-mangle-dos-filenames" );
330
331	if( symmetric ) {
332	_gpgme_gpg_add_arg( ctx->gpg, "--symmetric" );
333	_gpgme_encrypt_add_cipher( ctx );
334	rc = _gpgme_add_passphrase( ctx );
335	if( rc ) {
336	_gpgme_gpg_release( &ctx->gpg );
337	return rc;
338	}
339	}
340	else {
341	if( ctx->use_throwkeyid )
342	_gpgme_gpg_add_arg( ctx->gpg, "--throw-keyid" );
343	if( ctx->force_trust )
344	_gpgme_gpg_add_arg( ctx->gpg, "--always-trust" );
345	if( recp )
346	_gpgme_append_gpg_args_from_recipients( recp, ctx->gpg );
347	if( ctx->pipemode \|\| nfiles > 1 )
348	_gpgme_gpg_add_arg( ctx->gpg, "--encrypt-files" );
349	else
350	_gpgme_gpg_add_arg( ctx->gpg, "--encrypt" );
351
352	}
353
354	/* we cannot use --output for --encrypt-files */
355	if( nfiles == 1 && !ctx->pipemode && output ) {
356	_gpgme_gpg_add_arg( ctx->gpg, "--output" );
357	_gpgme_gpg_add_arg( ctx->gpg, output );
358	}
359	while( nfiles-- )
360	_gpgme_gpg_add_arg( ctx->gpg, *input++ );
361	rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
362	if( rc ) {
363	ctx->pending = 0;
364	_gpgme_gpg_release( &ctx->gpg );
365	}
366
367	return rc;
368	} /* file_encrypt_start */
369
370
371	static gpgme_error_t
372	get_encrypt_result (gpgme_ctx_t ctx)
373	{
374	struct encrypt_result_s * res;
375	gpgme_error_t err = 0;
376	int rc;
377
378	assert (ctx->result.encrypt);
379	res = ctx->result.encrypt;
380	if (res->okay)
381	return mk_error( No_Error );
382	if (res->no_recp)
383	err = mk_error (No_Recipients);
384	else if (res->inv_recp)
385	err = mk_error (Inv_Recipients);
386	else if ((rc = gpgme_get_process_rc (ctx )) != 0) {
387	DEBUG1 ("gpg return code=%d\n", rc);
388	err = mk_error (Internal_GPG_Problem);
389	}
390	else if (!res->okay \|\| (res->file_start != res->file_done))
391	err = mk_error (Encryption_Failed);
392	return err;
393	} /* get_encrypt_result */
394
395
396	/**
397	* gpgme_op_encrypt:
398	* @ctx: The context
399	* @recp: A set of recipients
400	* @in: plaintext input
401	* @out: ciphertext output
402	*
403	* This function encrypts @in to @out for all recipients from
404	* @recp. Other parameters are take from the context @c.
405	* The function does wait for the result.
406	*
407	* Return value: 0 on success or an errorcode.
408	**/
409	gpgme_error_t
410	gpgme_op_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t recp,
411	gpgme_data_t in, gpgme_data_t out )
412
413	{
414	gpgme_error_t err;
415
416	err = encrypt_start( ctx, recp, in, out );
417	if( !err ) {
418	gpgme_wait( ctx, 1 );
419	ctx->pending = 0;
420	if( ctx->use_tmpfiles ) {
421	_gpgme_data_read_from_tmpfile( out );
422	_gpgme_del_tmpfiles( ctx->wipe_fnc );
423	}
424	err = get_encrypt_result( ctx );
425	}
426
427	return err;
428	} /* gpgme_op_encrypt */
429
430
431	gpgme_error_t
432	gpgme_op_file_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t rset,
433	const char * input, const char * output )
434	{
435	gpgme_error_t err;
436	const char * files[1];
437
438	files[0] = input;
439	err = file_encrypt_start( ctx, rset, files, 1, output );
440	if( !err ) {
441	gpgme_wait( ctx, 1 );
442	ctx->pending = 0;
443	err = get_encrypt_result( ctx );
444	}
445
446	return err;
447	} /* gpgme_op_file_encrypt */
448
449
450	gpgme_error_t
451	gpgme_op_files_encrypt( gpgme_ctx_t ctx, gpgme_recipients_t rset,
452	const char ** files, size_t nfiles )
453	{
454	gpgme_error_t err;
455
456	/* fixme: the result is actually only for the last file. we need
457	a notification system which informs us with a callback
458	after each file is processed. */
459	if( use_symmetric( rset ) ) {
460	const char * s[1];
461	size_t i;
462
463	for( i=0; i < nfiles; i++ ) {
464	s[0] = files[i];
465	err = file_encrypt_start( ctx, NULL, s, 1, NULL );
466	if( !err ) {
467	gpgme_wait( ctx, 1 );
468	ctx->pending = 0;
469	err = get_encrypt_result( ctx );
470	}
471	if( err )
472	break;
473	}
474	}
475	else {
476	err = file_encrypt_start( ctx, rset, files, nfiles, NULL );
477	if( !err ) {
478	gpgme_wait( ctx, 1 );
479	ctx->pending = 0;
480	err = get_encrypt_result( ctx );
481	}
482	}
483	return err;
484	}
485
486
487	gpgme_error_t
488	gpgme_op_clip_encrypt( gpgme_recipients_t rset, int opts, gpgme_ctx_t *r_ctx )
489	{
490	gpgme_error_t err;
491	gpgme_ctx_t ctx = NULL;
492	gpgme_data_t plain = NULL;
493	gpgme_data_t ciph = NULL;
494
495	err = gpgme_new( &ctx );
496	if( err )
497	return err;
498
499	if( opts & GPGME_CTRL_TMPFILES )
500	gpgme_control( ctx, GPGME_CTRL_TMPFILES, 1 );
501	if( opts & GPGME_CTRL_FORCETRUST )
502	gpgme_control( ctx, GPGME_CTRL_FORCETRUST, 1 );
503	gpgme_control( ctx, GPGME_CTRL_ARMOR, 1 );
504
505	err = gpgme_data_new_from_clipboard (&plain);
506	if( !err )
507	err = gpgme_data_new( &ciph );
508	if( !err )
509	err = gpgme_op_encrypt( ctx, rset, plain, ciph );
510	if( !err ) {
511	gpgme_data_change_version( &ciph );
512	gpgme_data_release_and_set_clipboard( ciph );
513	}
514	if( r_ctx )
515	*r_ctx = ctx;
516	else
517	gpgme_release( ctx );
518	gpgme_data_release( plain );
519	return err;
520	} /* gpgme_op_clip_encrypt */
521
522
523	int
524	gpgme_recperr_count_items( gpgme_ctx_t ctx )
525	{
526	struct recp_info_s * r;
527	int ncount = 0;
528
529	if( !ctx )
530	return 0;
531	if( ctx->result_type != RESULT_TYPE_ENCRYPT )
532	return -1;
533	for( r = ctx->result.encrypt->inf; r; r = r->next )
534	ncount++;
535
536	return ncount;
537	} /* gpgme_recperr_count_items */
538
539
540	const char*
541	gpgme_recperr_get( gpgme_ctx_t ctx, int idx, gpgme_error_t *r_code )
542	{
543	struct recp_info_s * r;
544
545	if( !ctx )
546	return NULL;
547	if( idx > gpgme_recperr_count_items( ctx ) )
548	return NULL;
549	for( r = ctx->result.encrypt->inf; r && idx--; r = r->next )
550	;
551	if( r ) {
552	if( r_code )
553	*r_code = r->code;
554	return r->recp;
555	}
556
557	return NULL;
558	} /* gpgme_recperr_get_code */