debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-24 20:08:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/notmuch-reply.c

292 lines
8.4 KiB
C
Raw Normal View History

notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
/* notmuch - Not much of an email program, (just index and search)
*
* Copyright © 2009 Carl Worth
* Copyright © 2009 Keith Packard
*
* 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 3 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, see http://www.gnu.org/licenses/ .
*
* Authors: Carl Worth <cworth@cworth.org>
* Keith Packard <keithp@keithp.com>
*/
#include "notmuch-client.h"
#include "gmime-filter-reply.h"
static void
reply_part(GMimeObject *part, int *part_count)
{
GMimeContentDisposition *disposition;
GMimeContentType *content_type;
GMimeDataWrapper *wrapper;
(void) part_count;
disposition = g_mime_object_get_content_disposition (part);
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
{
const char *filename = g_mime_part_get_filename (GMIME_PART (part));
content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
printf ("Attachment: %s (%s)\n", filename,
g_mime_content_type_to_string (content_type));
return;
}
content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = NULL, *stream_filter = NULL;
stream_stdout = g_mime_stream_file_new (stdout);
if (stream_stdout) {
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
stream_filter = g_mime_stream_filter_new(stream_stdout);
}
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
g_mime_filter_reply_new(TRUE));
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref(stream_filter);
if (stream_stdout)
g_object_unref(stream_stdout);
}
else
{
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
notmuch reply: Don't reply to address belonging to the user. Here's our first real advantage of having a configuration system. We get to omit our own addresses from the recipient list of any replies.
2009-11-12 06:18:15 +01:00
/* Is the given address configured as one of the user's "personal" or
* "other" addresses. */
static int
address_is_users (const char *address, notmuch_config_t *config)
{
const char *primary;
char **other;
unsigned int i, other_len;
primary = notmuch_config_get_user_primary_email (config);
if (strcmp (primary, address) == 0)
return 1;
other = notmuch_config_get_user_other_email (config, &other_len);
for (i = 0; i < other_len; i++)
if (strcmp (other[i], address) == 0)
return 1;
return 0;
}
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
/* For each address in 'list' that is not configured as one of the
* user's addresses in 'config', add that address to 'message' as an
* address of 'type'.
*
* The first address encountered that *is* the user's address will be
* returned, (otherwise NULL is returned).
*/
static const char *
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
add_recipients_for_address_list (GMimeMessage *message,
notmuch reply: Don't reply to address belonging to the user. Here's our first real advantage of having a configuration system. We get to omit our own addresses from the recipient list of any replies.
2009-11-12 06:18:15 +01:00
notmuch_config_t *config,
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
GMimeRecipientType type,
InternetAddressList *list)
{
InternetAddress *address;
int i;
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
const char *ret = NULL;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
for (i = 0; i < internet_address_list_length (list); i++) {
address = internet_address_list_get_address (list, i);
if (INTERNET_ADDRESS_IS_GROUP (address)) {
InternetAddressGroup *group;
InternetAddressList *group_list;
group = INTERNET_ADDRESS_GROUP (address);
group_list = internet_address_group_get_members (group);
if (group_list == NULL)
continue;
notmuch reply: Don't reply to address belonging to the user. Here's our first real advantage of having a configuration system. We get to omit our own addresses from the recipient list of any replies.
2009-11-12 06:18:15 +01:00
add_recipients_for_address_list (message, config,
type, group_list);
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
} else {
InternetAddressMailbox *mailbox;
const char *name;
const char *addr;
mailbox = INTERNET_ADDRESS_MAILBOX (address);
name = internet_address_get_name (address);
addr = internet_address_mailbox_get_addr (mailbox);
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
if (address_is_users (addr, config)) {
if (ret == NULL)
ret = addr;
} else {
notmuch reply: Don't reply to address belonging to the user. Here's our first real advantage of having a configuration system. We get to omit our own addresses from the recipient list of any replies.
2009-11-12 06:18:15 +01:00
g_mime_message_add_recipient (message, type, name, addr);
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
}
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
}
}
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
return ret;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
}
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
/* For each address in 'recipients' that is not configured as one of
* the user's addresses in 'config', add that address to 'message' as
* an address of 'type'.
*
* The first address encountered that *is* the user's address will be
* returned, (otherwise NULL is returned).
*/
static const char *
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
add_recipients_for_string (GMimeMessage *message,
notmuch reply: Don't reply to address belonging to the user. Here's our first real advantage of having a configuration system. We get to omit our own addresses from the recipient list of any replies.
2009-11-12 06:18:15 +01:00
notmuch_config_t *config,
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
GMimeRecipientType type,
const char *recipients)
{
InternetAddressList *list;
list = internet_address_list_parse_string (recipients);
if (list == NULL)
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
return NULL;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
return add_recipients_for_address_list (message, config, type, list);
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
}
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
int
notmuch_reply_command (void *ctx, int argc, char *argv[])
{
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
notmuch_config_t *config;
notmuch_database_t *notmuch;
notmuch_query_t *query;
GMimeMessage *reply;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
char *query_string;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
notmuch_messages_t *messages;
notmuch_message_t *message;
int ret = 0;
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
const char *subject, *recipients, *from_addr = NULL;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
const char *in_reply_to, *orig_references, *references;
char *reply_headers;
struct {
const char *header;
GMimeRecipientType recipient_type;
} reply_to_map[] = {
{ "from", GMIME_RECIPIENT_TYPE_TO },
{ "to", GMIME_RECIPIENT_TYPE_TO },
{ "cc", GMIME_RECIPIENT_TYPE_CC },
{ "bcc", GMIME_RECIPIENT_TYPE_BCC }
};
unsigned int i;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
config = notmuch_config_open (ctx, NULL, NULL);
if (config == NULL)
return 1;
notmuch = notmuch_database_open (notmuch_config_get_database_path (config));
if (notmuch == NULL)
return 1;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
query_string = query_string_from_args (ctx, argc, argv);
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
if (query_string == NULL) {
fprintf (stderr, "Out of memory\n");
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
return 1;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
}
query = notmuch_query_create (notmuch, query_string);
if (query == NULL) {
fprintf (stderr, "Out of memory\n");
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
return 1;
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
}
for (messages = notmuch_query_search_messages (query);
notmuch_messages_has_more (messages);
notmuch_messages_advance (messages))
{
message = notmuch_messages_get (messages);
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
/* The 1 means we want headers in a "pretty" order. */
reply = g_mime_message_new (1);
if (reply == NULL) {
fprintf (stderr, "Out of memory\n");
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
return 1;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
}
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
subject = notmuch_message_get_header (message, "subject");
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
if (strncasecmp (subject, "Re:", 3))
subject = talloc_asprintf (ctx, "Re: %s", subject);
g_mime_message_set_subject (reply, subject);
for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
const char *addr;
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
recipients = notmuch_message_get_header (message,
reply_to_map[i].header);
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
addr = add_recipients_for_string (reply, config,
reply_to_map[i].recipient_type,
recipients);
if (from_addr == NULL)
from_addr = addr;
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
}
notmuch reply: Fish out user's address from recipient list to use as From. That is, if mail was addresses to one of the "other" addresses in the configuration file, then the reply will have its "From" header set to that same address rather than the primary address.
2009-11-12 06:29:04 +01:00
if (from_addr == NULL)
from_addr = notmuch_config_get_user_primary_email (config);
from_addr = talloc_asprintf (ctx, "%s <%s>",
notmuch_config_get_user_name (config),
from_addr);
g_mime_object_set_header (GMIME_OBJECT (reply),
"From", from_addr);
notmuch reply: Add Bcc to the user's primary email address. The user really wants a copy of all outbound messages to come back in.
2009-11-12 20:08:36 +01:00
g_mime_object_set_header (GMIME_OBJECT (reply), "Bcc",
notmuch_config_get_user_primary_email (config));
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
in_reply_to = talloc_asprintf (ctx, "<%s>",
notmuch_message_get_message_id (message));
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
g_mime_object_set_header (GMIME_OBJECT (reply),
"In-Reply-To", in_reply_to);
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
orig_references = notmuch_message_get_header (message, "references");
references = talloc_asprintf (ctx, "%s%s%s",
orig_references ? orig_references : "",
orig_references ? " " : "",
in_reply_to);
g_mime_object_set_header (GMIME_OBJECT (reply),
"References", references);
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
reply_headers = g_mime_object_to_string (GMIME_OBJECT (reply));
printf ("%s", reply_headers);
free (reply_headers);
notmuch reply: Process headers a bit more accurately. We know take the original From: and all recipients and put them on the To: line. We also add a "Re: " to the subject, and we add In-Reply-To: and References: headers.
2009-11-11 03:46:26 +01:00
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
g_object_unref (G_OBJECT (reply));
reply = NULL;
printf ("On %s, %s wrote:\n",
notmuch_message_get_header (message, "date"),
notmuch_message_get_header (message, "from"));
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
show_message_body (notmuch_message_get_filename (message), reply_part);
notmuch_message_destroy (message);
}
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
notmuch_query_destroy (query);
notmuch_database_close (notmuch);
notmuch reply: Use GMime to construct the header for the reply. The advantage here is that we actually get the necessary folding of long headers, (particularly the References header, but also things like Subject). This also gives us parsed recipient addresses so that we can easily elide the sender's address(es) from the recipient list (just as soon as we have a configured value for the recipient's address(es)).
2009-11-11 19:54:12 +01:00
notmuch reply: Add (incomplete) reply command Reviewed-by: Carl Worth <cworth@cworth.org> Keith wrote all the code here against notmuch before notmuch.c was split up into multiple files. So I've pushed the code around in various ways to match the new code structure, but have generally tried to avoid making any changes to the behavior of the code. I did fix one bug---a missing call to g_mime_stream_file_set_owner in show_part which would cause "notmuch show" to go off into the weeds when trying to show multiple messages, (since the first stream would fclose stdout).
2009-11-06 19:00:38 +01:00
return ret;
}
Reference in a new issue Copy permalink