gpgme_error_t KGpgMe::readToBuffer(gpgme_data_t in, QByteArray* outBuffer) const
{
int ret;
gpgme_error_t err = GPG_ERR_NO_ERROR;
ret = gpgme_data_seek(in, 0, SEEK_SET);
if(ret) {
err = gpgme_err_code_from_errno(errno);
}
else {
char* buf = new char[BUF_SIZE + 2];
if(buf) {
while((ret = gpgme_data_read(in, buf, BUF_SIZE)) > 0) {
uint size = outBuffer->size();
outBuffer->resize(size + ret);
memcpy(outBuffer->data() + size, buf, ret);
}
if(ret < 0)
err = gpgme_err_code_from_errno(errno);
delete[] buf;
}
}
return err;
}
static void
print_data (gpgme_data_t dh)
{
#define BUF_SIZE 512
char buf[BUF_SIZE + 1];
int ret;
ret = gpgme_data_seek (dh, 0, SEEK_SET);
if (ret)
fail_if_err (gpgme_err_code_from_errno (errno));
while ((ret = gpgme_data_read (dh, buf, BUF_SIZE)) > 0)
fwrite (buf, ret, 1, stdout);
if (ret < 0)
fail_if_err (gpgme_err_code_from_errno (errno));
}
char* gpgData2Char(gpgme_data_t dh, int* newsize)
{
size_t tmpsize;
char* newbuffer;
char* tmpbuffer;
TRACE(99, "gpgData2Char()", NULL);
newbuffer = NULL;
*newsize = 0;
/* we have to rewind the buffer */
if (gpgme_data_seek(dh, 0, SEEK_SET))
{
gpgError(gpgme_err_code_from_errno(errno));
return NULL;
}
tmpbuffer = memAlloc(__FILE__, __LINE__, BUFFERSIZE + 1);
while ((tmpsize = gpgme_data_read(dh, tmpbuffer, BUFFERSIZE)) > 0)
{
newbuffer = memRealloc(__FILE__, __LINE__, newbuffer,
*newsize, *newsize + tmpsize);
/* Flawfinder: ignore */
memcpy(newbuffer + *newsize, tmpbuffer, tmpsize);
*newsize += tmpsize;
}
memFree(__FILE__, __LINE__, tmpbuffer, BUFFERSIZE + 1);
if (tmpsize < 0)
{
gpgError(gpgme_err_code_from_errno(errno));
return NULL;
}
return newbuffer;
}
int read_data(char *buf, int buf_size) {
int ret;
strcpy(buf,"");
if((ret = gpgme_data_read(_cf_out, buf, buf_size)) > 0)
buf[ret] = '\0';
if(ret < 0)
fail_if_err(gpgme_err_code_from_errno(errno));
if(ret > 0) {
return 1;
} else {
gpgme_data_release(_cf_out);
return 0;
}
}
void encrypt(const char *message, char *dest, const char *fingerprint)
{
gpgme_data_t in;
gpgme_key_t key[2] = { NULL, NULL };
gpgme_encrypt_result_t result;
init_cryptofox();
gpgme_set_armor (_cf_ctx, 1);
_cf_err = gpgme_data_new_from_mem (&in, message, strlen(message), 0);
fail_if_err (_cf_err);
_cf_err = gpgme_data_new (&_cf_out);
fail_if_err (_cf_err);
// my key ([email protected])
_cf_err = gpgme_get_key (_cf_ctx, fingerprint,
&key[0], 0);
fail_if_err (_cf_err);
// err = gpgme_get_key(ctx,"C0C13F91F6F111E8C66CA6E518A66F16FBFD6A72",
// &key[1], 0);
// fail_if_err (err);
_cf_err = gpgme_op_encrypt (_cf_ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, _cf_out);
fail_if_err (_cf_err);
result = gpgme_op_encrypt_result (_cf_ctx);
if (result->invalid_recipients)
{
fprintf (stderr, "Invalid recipient encountered: %s\n",
result->invalid_recipients->fpr);
exit (1);
}
int ret;
ret = gpgme_data_seek(_cf_out, 0, SEEK_SET);
if(ret)
fail_if_err(gpgme_err_code_from_errno(errno));
gpgme_key_unref (key[0]);
gpgme_data_release (in);
gpgme_release (_cf_ctx);
}
static gboolean
import_start (SeahorseToolMode *mode, const gchar *uri, gpgme_data_t uridata,
SeahorsePGPOperation *pop, GError **err)
{
size_t size;
SeahorseOperation *op;
gpgme_error_t gerr;
/* Start actual import */
op = SEAHORSE_OPERATION (pop);
init_crypt();
buffer = g_malloc0(IMPORT_BUFFER_SIZE); /* Allocate memory for key data */
size = gpgme_data_read (uridata, (void*) buffer, IMPORT_BUFFER_SIZE);
if (size > 0) {
import_proxy_call = dbus_g_proxy_begin_call (dbus_key_proxy, "ImportKeys",
proxy_call_notification,
pop, NULL,
G_TYPE_STRING, "openpgp",
G_TYPE_STRING, buffer,
G_TYPE_INVALID);
seahorse_operation_mark_start (op);
seahorse_operation_mark_progress (op, _("Importing keys ..."), 0.5);
} else {
g_free (buffer);
gerr = gpgme_err_code_from_errno (errno);
seahorse_util_gpgme_to_error (gerr, err);
return FALSE;
}
return TRUE;
}
