/*
* e-signature-utils.c
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*/
#include "e-signature-utils.h"
#include <errno.h>
#include <glib/gstdio.h>
#include <gconf/gconf-client.h>
#include <camel/camel-stream.h>
#include <camel/camel-stream-fs.h>
#include <camel/camel-stream-mem.h>
#include <camel/camel-stream-filter.h>
#include <camel/camel-mime-filter-charset.h>
#include <camel/camel-mime-filter-tohtml.h>
#ifndef G_OS_WIN32
#include <sys/wait.h>
#endif
#include "e-util/e-util.h"
static ESignatureList *global_signature_list;
ESignatureList *
e_get_signature_list (void)
{
if (G_UNLIKELY (global_signature_list == NULL)) {
GConfClient *client;
client = gconf_client_get_default ();
global_signature_list = e_signature_list_new (client);
g_object_unref (client);
}
g_return_val_if_fail (global_signature_list != NULL, NULL);
return global_signature_list;
}
ESignature *
e_get_signature_by_name (const gchar *name)
{
ESignatureList *signature_list;
const ESignature *signature;
e_signature_find_t find;
g_return_val_if_fail (name != NULL, NULL);
find = E_SIGNATURE_FIND_NAME;
signature_list = e_get_signature_list ();
signature = e_signature_list_find (signature_list, find, name);
/* XXX ESignatureList misuses const. */
return (ESignature *) signature;
}
ESignature *
e_get_signature_by_uid (const gchar *uid)
{
ESignatureList *signature_list;
const ESignature *signature;
e_signature_find_t find;
g_return_val_if_fail (uid != NULL, NULL);
find = E_SIGNATURE_FIND_UID;
signature_list = e_get_signature_list ();
signature = e_signature_list_find (signature_list, find, uid);
/* XXX ESignatureList misuses const. */
return (ESignature *) signature;
}
gchar *
e_create_signature_file (GError **error)
{
const gchar *data_dir;
gchar basename[32];
gchar *filename;
gchar *pathname;
gint32 ii;
data_dir = e_get_user_data_dir ();
pathname = g_build_filename (data_dir, "signatures", NULL);
filename = NULL;
if (g_mkdir_with_parents (pathname, 0700) < 0) {
g_set_error (
error, G_FILE_ERROR,
g_file_error_from_errno (errno),
"%s: %s", pathname, g_strerror (errno));
g_free (pathname);
return NULL;
}
for (ii = 0; ii < G_MAXINT32; ii++) {
g_snprintf (
basename, sizeof (basename),
"signature-%" G_GINT32_FORMAT, ii);
g_free (filename);
filename = g_build_filename (pathname, basename, NULL);
if (!g_file_test (filename, G_FILE_TEST_EXISTS)) {
gint fd;
fd = g_creat (filename, 0600);
if (fd >= 0) {
close (fd);
break;
}
/* If we failed once we're probably going
* to continue failing, so just give up. */
g_set_error (
error, G_FILE_ERROR,
g_file_error_from_errno (errno),
"%s: %s", filename, g_strerror (errno));
g_free (filename);
filename = NULL;
break;
}
}
/* If there are actually G_MAXINT32 signature files, the
* most recent signature file we be overwritten. Sorry. */
return filename;
}
gchar *
e_read_signature_file (ESignature *signature,
gboolean convert_to_html,
GError **error)
{
CamelStream *input_stream;
CamelStream *output_stream;
GByteArray *buffer;
gchar *content;
gsize length;
gint fd;
g_return_val_if_fail (E_IS_SIGNATURE (signature), NULL);
fd = g_open (signature->filename, O_RDONLY, 0);
if (fd < 0) {
g_set_error (
error, G_FILE_ERROR,
g_file_error_from_errno (errno),
"%s: %s", signature->filename,
g_strerror (errno));
return NULL;
}
input_stream = camel_stream_fs_new_with_fd (fd);
if (!signature->html && convert_to_html) {
CamelStreamFilter *filtered_stream;
CamelMimeFilter *filter;
gint32 flags;
filtered_stream =
camel_stream_filter_new_with_stream (input_stream);
camel_object_unref (input_stream);
flags =
CAMEL_MIME_FILTER_TOHTML_PRESERVE_8BIT |
CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS |
CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES |
CAMEL_MIME_FILTER_TOHTML_CONVERT_SPACES;
filter = camel_mime_filter_tohtml_new (flags, 0);
camel_stream_filter_add (filtered_stream, filter);
camel_object_unref (filter);
input_stream = (CamelStream *) filtered_stream;
}
buffer = g_byte_array_new ();
output_stream = camel_stream_mem_new ();
camel_stream_mem_set_byte_array (
CAMEL_STREAM_MEM (output_stream), buffer);
camel_stream_write_to_stream (input_stream, output_stream);
camel_object_unref (output_stream);
camel_object_unref (input_stream);
/* Make sure the buffer is nul-terminated. */
length = (gsize) buffer->len;
g_byte_array_append (buffer, (guint8 *) "", 1);
content = (gchar *) g_byte_array_free (buffer, FALSE);
/* Signatures are saved as UTF-8, but we still need to check that
* the signature is valid UTF-8 because the user may be opening
* a signature file that is in his/her locale character set. If
* it's not in UTF-8 then try converting from the current locale. */
if (!g_utf8_validate (content, length, NULL)) {
gchar *utf8;
utf8 = g_locale_to_utf8 (content, length, NULL, NULL, error);
g_free (content);
content = utf8;
}
return content;
}
gchar *
e_run_signature_script (const gchar *filename)
{
/* FIXME Make this cross-platform, prefer GLib functions over
* POSIX, and report errors via GError instead of dumping
* messages to the terminal where users won't see them. */
#ifndef G_OS_WIN32
gint in_fds[2];
pid_t pid;
g_return_val_if_fail (filename != NULL, NULL);
if (pipe (in_fds) == -1) {
g_warning (
"Failed to create pipe to '%s': %s",
filename, g_strerror (errno));
return NULL;
}
pid = fork ();
/* Child Process */
if (pid == 0) {
gint maxfd, ii;
close (in_fds[0]);
if (dup2 (in_fds[1], STDOUT_FILENO) < 0)
_exit (255);
close (in_fds[1]);
setsid ();
maxfd = sysconf (_SC_OPEN_MAX);
for (ii = 3; ii < maxfd; ii++) {
if (ii == STDIN_FILENO)
continue;
if (ii == STDOUT_FILENO)
continue;
if (ii == STDERR_FILENO)
continue;
fcntl (ii, F_SETFD, FD_CLOEXEC);
}
execlp ("/bin/sh", "/bin/sh", "-c", filename, NULL);
g_warning (
"Could not execute '%s': %s",
filename, g_strerror (errno));
_exit (255);
/* Parent Process */
} else if (pid > 0) {
CamelStream *output_stream;
CamelStream *input_stream;
GByteArray *buffer;
gchar *content;
gsize length;
gint result;
gint status;
close (in_fds[1]);
buffer = g_byte_array_new ();
output_stream = camel_stream_mem_new ();
camel_stream_mem_set_byte_array (
CAMEL_STREAM_MEM (output_stream), buffer);
input_stream = camel_stream_fs_new_with_fd (in_fds[0]);
camel_stream_write_to_stream (input_stream, output_stream);
camel_object_unref (input_stream);
camel_object_unref (output_stream);
/* Make sure the buffer is nul-terminated. */
length = (gsize) buffer->len;
g_byte_array_append (buffer, (guchar *) "", 1);
content = (gchar *) g_byte_array_free (buffer, FALSE);
/* Signature scripts are supposed to generate UTF-8 content,
* but because users are known to never read the manual, we
* try to do our best if the content isn't valid UTF-8 by
* assuming that the content is in the user's locale
* character set. */
if (!g_utf8_validate (content, length, NULL)) {
gchar *utf8;
/* XXX Should pass a GError here. */
utf8 = g_locale_to_utf8 (
content, length, NULL, NULL, NULL);
g_free (content);
content = utf8;
}
/* Wait for the script process to terminate. */
result = waitpid (pid, &status, 0);
if (result == -1 && errno == EINTR) {
/* Child process is hanging... */
kill (pid, SIGTERM);
sleep (1);
result = waitpid (pid, &status, WNOHANG);
if (result == 0) {
/* ...still hanging, set phasers to KILL. */
kill (pid, SIGKILL);
sleep (1);
result = waitpid (pid, &status, WNOHANG);
}
}
return content;
/* Forking Failed */
} else {
g_warning (
"Failed to create child process '%s': %s",
filename, g_strerror (errno));
close (in_fds[0]);
close (in_fds[1]);
}
#endif
return NULL;
}
