LPSTR __cdecl _gpg_encrypt(LPCSTR message, LPCSTR keyid)
{
char buffer[ciphertextsize];
char *encmessage = 0;
int encmessagelen;
gpgResult gpgresult;
if(strlen(keyid))
{
ZeroMemory(buffer, sizeof(buffer));
gpgresult=gpgEncrypt(buffer, keyid, message);
if(gpgresult!=gpgSuccess)
return 0;
encmessagelen = strlen(buffer)+1;
encmessage = (char *) LocalAlloc(LPTR,encmessagelen);
MoveMemory(encmessage, buffer, encmessagelen);
}
return encmessage;
}
/* #############################################################################
*
* Description encrypt and write our data to the given filename
* Author Harry Brueckner
* Date 2005-03-18
* Arguments char* filename - filename to write to
* char** errormsg - pointer to the GpgMe error message, if any
* PASSPHRASE_FN - passphrase callback function
* SHOWERROR_FN - callback function for error messages
* Return 1 on error, otherwise 0
*/
int xmlDataFileWrite(char* filename, char** errormsg,
PASSPHRASE_FN passphrase_cb, SHOWERROR_FN showerror_cb)
{
xmlNode* rootnode;
xmlChar* xmlbuffer = NULL;
int error = 0,
fd,
gpgsize = 0,
size;
char* buffer = NULL;
char* gpgbuffer = NULL;
char* tmpbuffer = NULL;
/* we initialize the error message */
*errormsg = NULL;
/* update the modification date of the root node */
rootnode = xmlDocGetRootElement(xmldoc);
if (rootnode)
{ xmlSetModification(rootnode); }
/* we create the memory buffer */
xmlDocDumpMemoryEnc(xmldoc, &xmlbuffer, &size, config -> encoding);
buffer = (char*)xmlbuffer;
if (buffer && !error && config -> encryptdata)
{ /* we have a buffer and must compress it */
error = zlibCompress(buffer, size, &gpgbuffer, &gpgsize, errormsg);
if (error)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("error (%s) compressing file '%s'."),
*errormsg,
filename);
showerror_cb(_("compression error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
xmlFree(buffer);
buffer = gpgbuffer;
size = gpgsize;
}
else if (buffer && !error && !config -> encryptdata)
{ /* we don't have to encrypt data, so nothing is compressed */
gpgbuffer = memAlloc(__FILE__, __LINE__, size);
/* Flawfinder: ignore */
memcpy(gpgbuffer, buffer, size);
xmlFree(buffer);
buffer = gpgbuffer;
}
if (buffer && !error &&
config -> encryptdata)
{
error = gpgEncrypt(buffer, size, &gpgbuffer, &gpgsize, passphrase_cb,
showerror_cb);
if (error)
{ *errormsg = _("could not encrypt database file."); }
memFree(__FILE__, __LINE__, buffer, size);
buffer = gpgbuffer;
size = gpgsize;
}
else
{
showerror_cb(_("warning"),
_("the database file is written in unecrypted mode."));
}
if (buffer && !error)
{ /* if we have a buffer we write the file */
createBackupfile(filename, showerror_cb);
fd = fileLockOpen(filename, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, &tmpbuffer);
if (fd == -1)
{ /* error opening the file */
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
*errormsg = strerror(errno);
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
if (write(fd, buffer, size) != size)
{ /* error writing the file */
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("error %d (%s) writing file '%s'."),
errno,
strerror(errno),
filename);
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
*errormsg = strerror(errno);
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
lockf(fd, F_UNLCK, 0L);
close(fd);
}
if (buffer && size)
{ memFree(__FILE__, __LINE__, buffer, size); }
return error;
}
