#include <math.h>
#include <sys/wait.h>
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <gpgme.h>

#define MAXSIZE	2048

//Hier kommt das MANTRA rein
char			*GPG_PASSPHRASE="test";

struct passphrase_cb_info_s {
    GpgmeCtx c;
    int did_it;
};
static const char *passphrase_cb ( void *opaque, const char *desc, void *r_hd );

int main(int argc, char *argv[])
{
	char		*fingerprint="Joe Tester ((pp=test)) <joe@foo.bar>";
	char		message[MAXSIZE];
	strcpy(message,"Dies ist ein Test");
	gen_key();
	encrypt_message(fingerprint,message);
	printf("%s\n",message);
}

int encrypt_message(char *fingerprint, char *message)
{
	size_t nread;
	GpgmeCtx ctx;
    GpgmeError err;
    GpgmeData in, out;
    GpgmeRecipients rset;

	err = gpgme_check_engine ();
    if (err) exit(1);

	err = gpgme_new (&ctx);
    if (err) exit(1);
    gpgme_set_armor (ctx, 1);

    err = gpgme_data_new_from_mem ( &in, message, strlen(message), 0 );
    if (err) exit(1);

    err = gpgme_data_new ( &out );
    if (err) exit(1);

    err = gpgme_recipients_new (&rset);
    if (err) exit(1);
    err = gpgme_recipients_add_name_with_validity (rset, fingerprint,
                                                   GPGME_VALIDITY_FULL);
    if (err) exit(1);

    err = gpgme_op_encrypt (ctx, rset, in, out );

	if (err) return(0);


    fflush (NULL);
    err = gpgme_data_rewind ( out );
    if (err) exit(1);
    err = gpgme_data_read ( out, message, MAXSIZE, &nread );

	gpgme_recipients_release (rset);
    gpgme_data_release (in);
    gpgme_data_release (out);
    gpgme_release (ctx);

	return(-1);
}

/* ---------------------------------------------------------------- */
/* File Operations                                                   */
/* ---------------------------------------------------------------- */


int decrypt_file(char *fingerprint, char *filename)
{
	int 	ret,cnt=0;
	char    outfilename[MAXSIZE];
	char  	*buf_ptr;
	char		buf[100];
	FILE	*outfile;
	GpgmeCtx ctx;
    GpgmeError err;
    GpgmeData in, out, pwdata = NULL;
    struct passphrase_cb_info_s info;
	char	c;
	size_t nread;


	strncpy(outfilename,filename,strlen(filename)-4);
	outfilename[strlen(filename)-4]='\0';
	printf("%s\n",outfilename);

    err = gpgme_new (&ctx);
    if (err) exit(1);
    if ( !getenv("GPG_AGENT_INFO") ) {
        memset ( &info, 0, sizeof info );
        info.c = ctx;
        gpgme_set_passphrase_cb ( ctx, passphrase_cb, &info );
    }

    err = gpgme_data_new_from_file ( &in, filename, 1);
    if (err) exit(1);

    err = gpgme_data_new ( &out );
    if (err) exit(1);

    err = gpgme_op_decrypt (ctx, in, out );

	if (err)
	{
		return(0);
	}

    fflush (NULL);

	err = gpgme_data_rewind ( out );
    if (err) exit(1);
	outfile=fopen(outfilename,"w");
	while ( !(err = gpgme_data_read ( out, buf, 100, &nread )) )
	{

		fwrite ( buf, nread, 1, outfile );
	}
	fclose(outfile);
	gpgme_data_release (in);
    gpgme_data_release (out);
    gpgme_data_release (pwdata);
    gpgme_release (ctx);
	strcpy(filename,outfilename);

	return(-1);


}
static void
progress ( void *self, const char *what, int type, int current, int total)
{
    fprintf (stderr, "progress `%s' %d %d %d\n", what, type, current, total);
}


int gen_key ()
{
    GpgmeCtx ctx;
    GpgmeError err;
    const char *format;
    char *parms;
    int count = 0;

    err = gpgme_new (&ctx);
    if (err) exit(1);

    gpgme_set_progress_cb (ctx, progress, NULL);

    parms = "<GnupgKeyParms format=\"internal\">\n"
             "Key-Type: DSA\n"
             "Key-Length: 1024\n"
             "Subkey-Type: ELG-E\n"
             "Subkey-Length: 1024\n"
             "Name-Real: Joe Tester\n"
             "Name-Comment: (pp=test)\n"
             "Name-Email: joe@foo.bar\n"
             "Expire-Date: 0\n"
             "Passphrase: test\n"
             "</GnupgKeyParms>\n";
    err = gpgme_op_genkey (ctx, parms, NULL, NULL );
    if (err) exit(1);

    gpgme_release (ctx);
    return 0;
}

/* ------------------------------------------------------------------- */
/* GPGme HilfsFunktionen                                                */
/* ------------------------------------------------------------------- */

static void print_op_info (GpgmeCtx c)
{
    char *s = gpgme_get_op_info (c, 0);

    if (!s)
        puts ("<!-- no operation info available -->");
    else {
        puts (s);
        free (s);
    }
}

static void print_data ( GpgmeData dh )
{
    char buf[100];
    size_t nread;
    GpgmeError err;

    err = gpgme_data_rewind ( dh );
    if (err) exit(1);
    while ( !(err = gpgme_data_read ( dh, buf, 100, &nread )) ) {
        fwrite ( buf, nread, 1, stdout );
    }
    if (err != GPGME_EOF)
        if (err) exit(1);
}



static const char *passphrase_cb ( void *opaque, const char *desc, void *r_hd )
{
    const char *pass;
    if ( !desc ) {
		return NULL;
    }
    return (GPG_PASSPHRASE);
}