Sylpheed

/*

 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client

 * Copyright (C) 2001 Werner Koch (dd9jn)

 *

 * This program 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.

 *

 * This program 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.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#if USE_GPGME

#include "defs.h"

#include <glib.h>

#include <stdio.h>

#include <string.h>

#include <locale.h>

#include <ctype.h>

#include <gpgme.h>

#include "intl.h"

#include "procmime.h"

#include "procheader.h"

#include "base64.h"

#include "uuencode.h"

#include "unmime.h"

#include "codeconv.h"

#include "utils.h"

#include "prefs_common.h"

#include "passphrase.h"

#include "select-keys.h"

#include "sigstatus.h"

#include "rfc2015.h"

#define DIM(v)     (sizeof(v)/sizeof((v)[0]))

static char *content_names[] = {

    "Content-Type",

    "Content-Disposition",

    "Content-Transfer-Encoding",

    NULL

};

static char *mime_version_name[] = {

    "Mime-Version",

    NULL

};

#if 0

static void dump_mimeinfo (const char *text, MimeInfo *x)

{

    debug_print ("MimeInfo[%s] %p  level=%d\n",

               text, x, x? x->level:0 );

    if (!x)

        return;

    debug_print ("      enc=`%s' enc_type=%d mime_type=%d\n",

               x->encoding, x->encoding_type, x->mime_type );

    debug_print ("      cont_type=`%s' cs=`%s' name=`%s' bnd=`%s'\n",

               x->content_type, x->charset, x->name, x->boundary );

    debug_print ("      cont_disp=`%s' fname=`%s' fpos=%ld size=%u, lvl=%d\n",

               x->content_disposition, x->filename, x->fpos, x->size,

               x->level );

    dump_mimeinfo (".main", x->main );

    dump_mimeinfo (".sub", x->sub );

    dump_mimeinfo (".next", x->next );

    debug_print ("MimeInfo[.parent] %p\n", x );

    dump_mimeinfo (".children", x->children );

    dump_mimeinfo (".plaintext", x->plaintext );

}

static void dump_part ( MimeInfo *mimeinfo, FILE *fp )

{

    unsigned int size = mimeinfo->size;

    int c;

    if (fseek (fp, mimeinfo->fpos, SEEK_SET)) {

        debug_print ("dump_part: fseek error\n");

        return;

    }

    debug_print ("--- begin dump_part ----\n");

    while (size-- && (c = getc (fp)) != EOF)

        putc (c, stderr);

    if (ferror (fp))

        debug_print ("dump_part: read error\n");

    debug_print ("--- end dump_part ----\n");

}

#endif

void

rfc2015_disable_all (void)

{

    /* FIXME: set a flag, so that we don't bother the user with failed

     * gpgme messages */

}

void

rfc2015_secure_remove (const char *fname)

{

    if (!fname)

        return;

    /* fixme: overwrite the file first */

    remove (fname);

}

static const gchar *

sig_status_to_string (GpgmeSigStat status)

{

    const gchar *result;

    switch (status) {

      case GPGME_SIG_STAT_NONE:

        result = _("Oops: Signature not verified");

        break;

      case GPGME_SIG_STAT_NOSIG:

        result = _("No signature found");

        break;

      case GPGME_SIG_STAT_GOOD:

        result = _("Good signature");

        break;

      case GPGME_SIG_STAT_BAD:

        result = _("BAD signature");

        break;

      case GPGME_SIG_STAT_NOKEY:

        result = _("No public key to verify the signature");

        break;

      case GPGME_SIG_STAT_ERROR:

        result = _("Error verifying the signature");

        break;

      case GPGME_SIG_STAT_DIFF:

        result = _("Different results for signatures");

        break;

      default:

        result = _("Error: Unknown status");

        break;

    }

    return result;

}

static const gchar *

sig_status_with_name (GpgmeSigStat status)

{

    const gchar *result;

    switch (status) {

      case GPGME_SIG_STAT_NONE:

        result = _("Oops: Signature not verified");

        break;

      case GPGME_SIG_STAT_NOSIG:

        result = _("No signature found");

        break;

      case GPGME_SIG_STAT_GOOD:

        result = _("Good signature from \"%s\"");

        break;

      case GPGME_SIG_STAT_BAD:

        result = _("BAD signature from \"%s\"");

        break;

      case GPGME_SIG_STAT_NOKEY:

        result = _("No public key to verify the signature");

        break;

      case GPGME_SIG_STAT_ERROR:

        result = _("Error verifying the signature");

        break;

      case GPGME_SIG_STAT_DIFF:

        result = _("Different results for signatures");

        break;

      default:

        result = _("Error: Unknown status");

        break;

    }

    return result;

}

static void

sig_status_for_key(GString *str, GpgmeCtx ctx, GpgmeSigStat status,

                   GpgmeKey key, const gchar *fpr)

{

        gint idx = 0;

        const char *uid;

        uid = gpgme_key_get_string_attr (key, GPGME_ATTR_USERID, NULL, idx);

        if (uid == NULL) {

                g_string_sprintfa (str, "%s\n",

                                   sig_status_to_string (status));

                if ((fpr != NULL) && (*fpr != '\0'))

                        g_string_sprintfa (str, "Key fingerprint: %s\n", fpr);

                g_string_append (str, _("Cannot find user ID for this key."));

                return;

        }

        g_string_sprintfa (str, sig_status_with_name (status), uid);

        g_string_append (str, "\n");

        while (1) {

                uid = gpgme_key_get_string_attr (key, GPGME_ATTR_USERID,

                                                 NULL, ++idx);

                if (uid == NULL)

                        break;

                g_string_sprintfa (str, _("                aka \"%s\"\n"),

                                   uid);

        }

}

static gchar *

sig_status_full (GpgmeCtx ctx)

{

        GString *str;

        gint sig_idx = 0;

        GpgmeError err;

        GpgmeSigStat status;

        GpgmeKey key;

        const char *fpr;

        time_t created;

        struct tm *ctime_val;

        char ctime_str[80];

        gchar *retval;

        str = g_string_new ("");

        fpr = gpgme_get_sig_status (ctx, sig_idx, &status, &created);

        while (fpr != NULL) {

                if (created != 0) {

                        ctime_val = localtime (&created);

                        strftime (ctime_str, sizeof (ctime_str), "%c",

                                  ctime_val);

                        g_string_sprintfa (str,

                                           _("Signature made at %s\n"),

                                           ctime_str);

                }

                err = gpgme_get_sig_key (ctx, sig_idx, &key);

                if (err != 0) {

                        g_string_sprintfa (str, "%s\n",

                                           sig_status_to_string (status));

                        if ((fpr != NULL) && (*fpr != '\0'))

                                g_string_sprintfa (str,

                                                   _("Key fingerprint: %s\n"),

                                                   fpr);

                } else {

                        sig_status_for_key (str, ctx, status, key, fpr);

                        gpgme_key_unref (key);

                }

                g_string_append (str, "\n\n");

                fpr = gpgme_get_sig_status (ctx, ++sig_idx, &status, &created);

        }

        retval = str->str;

        g_string_free (str, FALSE);

        return retval;

}

static void check_signature (MimeInfo *mimeinfo, MimeInfo *partinfo, FILE *fp)

{

    GpgmeCtx ctx = NULL;

    GpgmeError err;

    GpgmeData sig = NULL, text = NULL;

    GpgmeSigStat status = GPGME_SIG_STAT_NONE;

    GpgmegtkSigStatus statuswindow = NULL;

    const char *result = NULL;

    gchar *tmp_file;

    gint n_exclude_chars = 0;

    if (prefs_common.gpg_signature_popup)

        statuswindow = gpgmegtk_sig_status_create ();

    err = gpgme_new (&ctx);

    if (err) {

        debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));

        goto leave;

    }

    /* don't include the last empty line.

       It does not belong to the signed text */

    if (mimeinfo->children->size > 0) {

        if (fseek(fp, mimeinfo->children->fpos + mimeinfo->children->size - 1,

                  SEEK_SET) < 0) {

            perror("fseek");

            goto leave;

        }

        if (fgetc(fp) == '\n') {

            n_exclude_chars++;

            if (mimeinfo->children->size > 1) {

                if (fseek(fp, mimeinfo->children->fpos + mimeinfo->children->size - 2,

                          SEEK_SET) < 0) {

                    perror("fseek");

                    goto leave;

                }

                if (fgetc(fp) == '\r')

                    n_exclude_chars++;

            }

        }

    }

    /* canonicalize the file part. */

    tmp_file = get_tmp_file();

    if (copy_file_part(fp, mimeinfo->children->fpos,

                       mimeinfo->children->size - n_exclude_chars,

                       tmp_file) < 0) {

        g_free(tmp_file);

        goto leave;

    }

    if (canonicalize_file_replace(tmp_file) < 0) {

        unlink(tmp_file);

        g_free(tmp_file);

        goto leave;

    }

    err = gpgme_data_new_from_file(&text, tmp_file, 1);

    unlink(tmp_file);

    g_free(tmp_file);

    if (!err)

        err = gpgme_data_new_from_filepart (&sig, NULL, fp,

                                            partinfo->fpos, partinfo->size);

    if (err) {

        debug_print ("gpgme_data_new_from_filepart failed: %s\n",

                   gpgme_strerror (err));

        goto leave;

    }

    err = gpgme_op_verify (ctx, sig, text, &status);

    if (err)  {

        debug_print ("gpgme_op_verify failed: %s\n", gpgme_strerror (err));

        goto leave;

    }

    /* FIXME: check what the heck this sig_status_full stuff is.

     * it should better go into sigstatus.c */

    g_free (partinfo->sigstatus_full);

    partinfo->sigstatus_full = sig_status_full (ctx);

leave:

    result = gpgmegtk_sig_status_to_string(status);

    debug_print("verification status: %s\n", result);

    if (prefs_common.gpg_signature_popup)

        gpgmegtk_sig_status_update (statuswindow, ctx);

    g_free (partinfo->sigstatus);

    partinfo->sigstatus = g_strdup (result);

    gpgme_data_release (sig);

    gpgme_data_release (text);

    gpgme_release (ctx);

    if (prefs_common.gpg_signature_popup)

        gpgmegtk_sig_status_destroy (statuswindow);

}

/*

 * Copy a gpgme data object to a temporary file and

 * return this filename

 */

#if 0

static char *

copy_gpgmedata_to_temp (GpgmeData data, guint *length)

{

    static int id;

    char *tmp;

    FILE *fp;

    char buf[100];

    size_t nread;

    GpgmeError err;

    tmp = g_strdup_printf("%s%cgpgtmp.%08x",

                          get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id );

    if ((fp = fopen(tmp, "wb")) == NULL) {

        FILE_OP_ERROR(tmp, "fopen");

        g_free(tmp);

        return NULL;

    }

    err = gpgme_data_rewind ( data );

    if (err)

        debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));

    while (!(err = gpgme_data_read (data, buf, 100, &nread))) {

        fwrite ( buf, nread, 1, fp );

    }

    if (err != GPGME_EOF)

        debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));

    fclose (fp);

    *length = nread;

    return tmp;

}

#endif

static GpgmeData

pgp_decrypt (MimeInfo *partinfo, FILE *fp)

{

    GpgmeCtx ctx = NULL;

    GpgmeError err;

    GpgmeData cipher = NULL, plain = NULL;

    struct passphrase_cb_info_s info;

    memset (&info, 0, sizeof info);

    err = gpgme_new (&ctx);

    if (err) {

        debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));

        goto leave;

    }

    err = gpgme_data_new_from_filepart (&cipher, NULL, fp,

                                        partinfo->fpos, partinfo->size);

    if (err) {

        debug_print ("gpgme_data_new_from_filepart failed: %s\n",

                     gpgme_strerror (err));

        goto leave;

    }

    err = gpgme_data_new (&plain);

    if (err) {

        debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));

        goto leave;

    }

    if (!getenv("GPG_AGENT_INFO")) {

        info.c = ctx;

        gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);

    }

    err = gpgme_op_decrypt (ctx, cipher, plain);

leave:

    gpgme_data_release (cipher);

    if (err) {

        gpgmegtk_free_passphrase();

        debug_print ("decryption failed: %s\n", gpgme_strerror (err));

        gpgme_data_release (plain);

        plain = NULL;

    }

    else

        debug_print ("** decryption succeeded\n");

    gpgme_release (ctx);

    return plain;

}

MimeInfo * rfc2015_find_signature (MimeInfo *mimeinfo)

{

    MimeInfo *partinfo;

    int n = 0;

    if (!mimeinfo)

        return NULL;

    if (g_strcasecmp (mimeinfo->content_type, "multipart/signed"))

        return NULL;

    debug_print ("** multipart/signed encountered\n");

    /* check that we have at least 2 parts of the correct type */

    for (partinfo = mimeinfo->children;

         partinfo != NULL; partinfo = partinfo->next) {

        if (++n > 1  && !g_strcasecmp (partinfo->content_type,

                                       "application/pgp-signature"))

            break;

    }

    return partinfo;

}

gboolean rfc2015_has_signature (MimeInfo *mimeinfo)

{

    return rfc2015_find_signature (mimeinfo) != NULL;

}

void rfc2015_check_signature (MimeInfo *mimeinfo, FILE *fp)

{

    MimeInfo *partinfo;

    partinfo = rfc2015_find_signature (mimeinfo);

    if (!partinfo)

        return;

#if 0

    g_message ("** yep, it is a pgp signature");

    dump_mimeinfo ("gpg-signature", partinfo );

    dump_part (partinfo, fp );

    dump_mimeinfo ("signed text", mimeinfo->children );

    dump_part (mimeinfo->children, fp);

#endif

    check_signature (mimeinfo, partinfo, fp);

}

int rfc2015_is_encrypted (MimeInfo *mimeinfo)

{

    if (!mimeinfo || mimeinfo->mime_type != MIME_MULTIPART)

        return 0;

    if (g_strcasecmp (mimeinfo->content_type, "multipart/encrypted"))

        return 0;

    /* fixme: we should check the protocol parameter */

    return 1;

}

gboolean rfc2015_msg_is_encrypted (const gchar *file)

{

        FILE *fp;

        MimeInfo *mimeinfo;

        int ret;

        if ((fp = fopen(file, "rb")) == NULL)

                return FALSE;

        mimeinfo = procmime_scan_mime_header(fp);

        if(!mimeinfo) {

                fclose(fp);

                return FALSE;

        }

        ret = rfc2015_is_encrypted(mimeinfo);

        procmime_mimeinfo_free_all(mimeinfo);

        return ret != 0 ? TRUE : FALSE;

}

static int

name_cmp(const char *a, const char *b)

{

    for( ; *a && *b; a++, b++) {

        if(*a != *b

           && toupper(*(unsigned char *)a) != toupper(*(unsigned char *)b))

            return 1;

    }

    return *a != *b;

}

static int

headerp(char *p, char **names)

{

    int i, c;

    char *p2;

    p2 = strchr(p, ':');

    if(!p2 || p == p2) {

        return 0;

    }

    if(p2[-1] == ' ' || p2[-1] == '\t') {

        return 0;

    }

    if(!names[0])

        return 1;

    c = *p2;

    *p2 = 0;

    for(i = 0 ; names[i] != NULL; i++) {

        if(!name_cmp (names[i], p))

            break;

    }

    *p2 = c;

    return names[i] != NULL;

}

#define DECRYPTION_ABORT() \

{ \

    procmime_mimeinfo_free_all(tmpinfo); \

    msginfo->decryption_failed = 1; \

    return; \

}

void rfc2015_decrypt_message (MsgInfo *msginfo, MimeInfo *mimeinfo, FILE *fp)

{

    static int id;

    MimeInfo *tmpinfo, *partinfo;

    int ver_ok = 0;

    char *fname;

    GpgmeData plain;

    FILE *dstfp;

    size_t nread;

    char buf[BUFFSIZE];

    int in_cline;

    GpgmeError err;

    g_return_if_fail (msginfo != NULL);

    g_return_if_fail (mimeinfo != NULL);

    g_return_if_fail (fp != NULL);

    g_return_if_fail (mimeinfo->mime_type == MIME_MULTIPART);

    debug_print ("** decrypting multipart/encrypted message\n");

    /* skip headers */

    if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)

        perror("fseek");

    tmpinfo = procmime_scan_mime_header(fp);

    if (!tmpinfo || tmpinfo->mime_type != MIME_MULTIPART) {

        DECRYPTION_ABORT();

    }

    procmime_scan_multipart_message(tmpinfo, fp);

    /* check that we have the 2 parts */

    partinfo = tmpinfo->children;

    if (!partinfo || !partinfo->next) {

        DECRYPTION_ABORT();

    }

    if (!g_strcasecmp (partinfo->content_type, "application/pgp-encrypted")) {

        /* Fixme: check that the version is 1 */

        ver_ok = 1;

    }

    partinfo = partinfo->next;

    if (ver_ok &&

        !g_strcasecmp (partinfo->content_type, "application/octet-stream")) {

        if (partinfo->next)

            g_warning ("oops: pgp_encrypted with more than 2 parts");

    }

    else {

        DECRYPTION_ABORT();

    }

    debug_print ("** yep, it is pgp encrypted\n");

    plain = pgp_decrypt (partinfo, fp);

    if (!plain) {

        DECRYPTION_ABORT();

    }

    fname = g_strdup_printf("%s%cplaintext.%08x",

                            get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id);

    if ((dstfp = fopen(fname, "wb")) == NULL) {

        FILE_OP_ERROR(fname, "fopen");

        g_free(fname);

        DECRYPTION_ABORT();

    }

    /* write the orginal header to the new file */

    if (fseek(fp, tmpinfo->fpos, SEEK_SET) < 0)

        perror("fseek");

    in_cline = 0;

    while (fgets(buf, sizeof(buf), fp)) {

        if (headerp (buf, content_names)) {

            in_cline = 1;

            continue;

        }

        if (in_cline) {

            if (buf[0] == ' ' || buf[0] == '\t')

                continue;

            in_cline = 0;

        }

        if (buf[0] == '\r' || buf[0] == '\n')

            break;

        fputs (buf, dstfp);

    }

    err = gpgme_data_rewind (plain);

    if (err)

        debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));

    while (!(err = gpgme_data_read (plain, buf, sizeof(buf), &nread))) {

        fwrite (buf, nread, 1, dstfp);

    }

    if (err != GPGME_EOF) {

        debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));

    }

    fclose (dstfp);

    procmime_mimeinfo_free_all(tmpinfo);

    msginfo->plaintext_file = fname;

    msginfo->decryption_failed = 0;

}

#undef DECRYPTION_ABORT

/*

 * plain contains an entire mime object.

 * Encrypt it and return an GpgmeData object with the encrypted version of

 * the file or NULL in case of error.

 */

static GpgmeData

pgp_encrypt ( GpgmeData plain, GpgmeRecipients rset )

{

    GpgmeCtx ctx = NULL;

    GpgmeError err;

    GpgmeData cipher = NULL;

    err = gpgme_new (&ctx);

    if (!err)

        err = gpgme_data_new (&cipher);

    if (!err) {

        gpgme_set_armor (ctx, 1);

        err = gpgme_op_encrypt (ctx, rset, plain, cipher);

    }

    if (err) {

        debug_print ("encryption failed: %s\n", gpgme_strerror (err));

        gpgme_data_release (cipher);

        cipher = NULL;

    }

    else {

        debug_print ("** encryption succeeded\n");

    }

    gpgme_release (ctx);

    return cipher;

}

/*

 * Create and return a list of keys matching a key id

 */

GSList *rfc2015_create_signers_list (const char *keyid)

{

        GSList *key_list = NULL;

        GpgmeCtx list_ctx = NULL;

        GSList *p;

        GpgmeError err;

        GpgmeKey key;

        err = gpgme_new (&list_ctx);

        if (err)

                goto leave;

        err = gpgme_op_keylist_start (list_ctx, keyid, 1);

        if (err)

                goto leave;

        while ( !(err = gpgme_op_keylist_next (list_ctx, &key)) ) {

                key_list = g_slist_append (key_list, key);

        }

        if (err != GPGME_EOF)

                goto leave;

        err = 0;

        if (key_list == NULL) {

                debug_print ("no keys found for keyid \"%s\"\n", keyid);

        }

leave:

        if (err) {

                debug_print ("rfc2015_create_signers_list failed: %s\n", gpgme_strerror (err));

                for (p = key_list; p != NULL; p = p->next)

                        gpgme_key_unref ((GpgmeKey) p->data);

                g_slist_free (key_list);

        }

        if (list_ctx)

                gpgme_release (list_ctx);

        return err ? NULL : key_list;

}

/*

 * Encrypt the file by extracting all recipients and finding the

 * encryption keys for all of them.  The file content is then replaced

 * by the encrypted one.  */

int

rfc2015_encrypt (const char *file, GSList *recp_list, gboolean ascii_armored)

{

    FILE *fp = NULL;

    char buf[BUFFSIZE];

    int i, clineidx, saved_last;

    char *clines[3] = {NULL};

    GpgmeError err;

    GpgmeData header = NULL;

    GpgmeData plain = NULL;

    GpgmeData cipher = NULL;

    GpgmeRecipients rset = NULL;

    size_t nread;

    int mime_version_seen = 0;

    char *boundary;

    boundary = generate_mime_boundary ("Encrypt");

    /* Create the list of recipients */

    rset = gpgmegtk_recipient_selection (recp_list);

    if (!rset) {

        debug_print ("error creating recipient list\n" );

        goto failure;

    }

    /* Open the source file */

    if ((fp = fopen(file, "rb")) == NULL) {

        FILE_OP_ERROR(file, "fopen");

        goto failure;

    }

    err = gpgme_data_new (&header);

    if (!err)

        err = gpgme_data_new (&plain);

    if (err) {

        debug_print ("gpgme_data_new failed: %s\n", gpgme_strerror (err));

        goto failure;

    }

    /* get the content header lines from the source */

    clineidx = 0;

    saved_last = 0;

    while (!err && fgets(buf, sizeof(buf), fp)) {

        /* fixme: check for overlong lines */

        if (headerp (buf, content_names)) {

            if (clineidx >= DIM (clines)) {

                debug_print ("rfc2015_encrypt: too many content lines\n");

                goto failure;

            }

            clines[clineidx++] = g_strdup (buf);

            saved_last = 1;

            continue;

        }

        if (saved_last) {

            if (*buf == ' ' || *buf == '\t') {

                char *last = clines[clineidx - 1];

                clines[clineidx - 1] = g_strconcat (last, buf, NULL);

                g_free (last);

                continue;

            }

            saved_last = 0;

        }

        if (headerp (buf, mime_version_name))

            mime_version_seen = 1;

        if (buf[0] == '\r' || buf[0] == '\n')

            break;

        err = gpgme_data_write (header, buf, strlen (buf));

    }

    if (ferror (fp)) {

        FILE_OP_ERROR (file, "fgets");

        goto failure;

    }

    /* write them to the temp data and add the rest of the message */

    for (i = 0; !err && i < clineidx; i++) {

        debug_print ("%% %s:%d: cline=`%s'", __FILE__ ,__LINE__, clines[i]);

        err = gpgme_data_write (plain, clines[i], strlen (clines[i]));

    }

    if (!err)

        err = gpgme_data_write (plain, "\r\n", 2);

    while (!err && fgets(buf, sizeof(buf), fp)) {

        err = gpgme_data_write (plain, buf, strlen (buf));

    }

    if (ferror (fp)) {

        FILE_OP_ERROR (file, "fgets");

        goto failure;

    }

    if (err) {

        debug_print ("gpgme_data_write failed: %s\n", gpgme_strerror (err));

        goto failure;

    }

    cipher = pgp_encrypt (plain, rset);

    gpgme_data_release (plain); plain = NULL;

    gpgme_recipients_release (rset); rset = NULL;

    if (!cipher)

        goto failure;

    /* we have the encrypted message available in cipher and now we

     * are going to rewrite the source file. To be sure that file has

     * been truncated we use an approach which should work everywhere:

     * close the file and then reopen it for writing. It is important

     * that this works, otherwise it may happen that parts of the

     * plaintext are still in the file (The encrypted stuff is, due to

     * compression, usually shorter than the plaintext).

     *

     * Yes, there is a race condition here, but everyone, who is so

     * stupid to store the temp file with the plaintext in a public

     * directory has to live with this anyway. */

    if (fclose (fp)) {

        FILE_OP_ERROR(file, "fclose");

        goto failure;

    }

    if ((fp = fopen(file, "wb")) == NULL) {

        FILE_OP_ERROR(file, "fopen");

        goto failure;