Exemple #1
0
/* Does the address in the Reply-To header of 'message' already appear
 * in either the 'To' or 'Cc' header of the message?
 */
static int
reply_to_header_is_redundant (notmuch_message_t *message)
{
    const char *reply_to, *to, *cc, *addr;
    InternetAddressList *list;
    InternetAddress *address;
    InternetAddressMailbox *mailbox;

    reply_to = notmuch_message_get_header (message, "reply-to");
    if (reply_to == NULL || *reply_to == '\0')
	return 0;

    list = internet_address_list_parse_string (reply_to);

    if (internet_address_list_length (list) != 1)
	return 0;

    address = internet_address_list_get_address (list, 0);
    if (INTERNET_ADDRESS_IS_GROUP (address))
	return 0;

    mailbox = INTERNET_ADDRESS_MAILBOX (address);
    addr = internet_address_mailbox_get_addr (mailbox);

    to = notmuch_message_get_header (message, "to");
    cc = notmuch_message_get_header (message, "cc");

    if ((to && strstr (to, addr) != 0) ||
	(cc && strstr (cc, addr) != 0))
    {
	return 1;
    }

    return 0;
}
Exemple #2
0
static gboolean
fill_contact (MuMsgContact *self, InternetAddress *addr,
	      MuMsgContactType ctype)
{
	if (!addr)
		return FALSE;

	self->name = internet_address_get_name (addr);
	self->type = ctype;

	/* we only support internet mailbox addresses; if we don't
	 * check, g_mime hits an assert
	 */
	if (INTERNET_ADDRESS_IS_MAILBOX(addr))
		self->address = internet_address_mailbox_get_addr
			(INTERNET_ADDRESS_MAILBOX(addr));
	else
		self->address  = NULL;

	/* if there's no address, just a name, it's probably a local
	 * address (without @) */
	if (self->name && !self->address)
		self->address = self->name;

	/* note, the address could NULL e.g. when the recipient is something like
	 * 'Undisclosed recipients'
	 */
	return self->address != NULL;
}
Exemple #3
0
const gchar *
rspamd_task_get_sender (struct rspamd_task *task)
{
	InternetAddress *iaelt = NULL;
#ifdef GMIME24
	InternetAddressMailbox *imb;

	if (task->from_envelope != NULL) {
		iaelt = internet_address_list_get_address (task->from_envelope, 0);
	}
	else if (task->from_mime != NULL) {
		iaelt = internet_address_list_get_address (task->from_mime, 0);
	}
	imb = INTERNET_ADDRESS_IS_MAILBOX(iaelt) ?
			INTERNET_ADDRESS_MAILBOX (iaelt) : NULL;

	return (imb ? internet_address_mailbox_get_addr (imb) : NULL);
#else
	if (task->from_envelope != NULL) {
		iaelt = internet_address_list_get_address (task->from_envelope);
	}
	else if (task->from_mime != NULL) {
		iaelt = internet_address_list_get_address (task->from_mime);
	}

	return (iaelt != NULL ? internet_address_get_addr (iaelt) : NULL);
#endif
}
Exemple #4
0
/* Extract just the email address from the contents of a From:
 * header. */
static const char *
_extract_email_address (const void *ctx, const char *from)
{
    InternetAddressList *addresses;
    InternetAddress *address;
    InternetAddressMailbox *mailbox;
    const char *email = "MAILER-DAEMON";

    addresses = internet_address_list_parse_string (from);

    /* Bail if there is no address here. */
    if (addresses == NULL || internet_address_list_length (addresses) < 1)
        goto DONE;

    /* Otherwise, just use the first address. */
    address = internet_address_list_get_address (addresses, 0);

    /* The From header should never contain an address group rather
     * than a mailbox. So bail if it does. */
    if (! INTERNET_ADDRESS_IS_MAILBOX (address))
        goto DONE;

    mailbox = INTERNET_ADDRESS_MAILBOX (address);
    email = internet_address_mailbox_get_addr (mailbox);
    email = talloc_strdup (ctx, email);

DONE:
    if (addresses)
        g_object_unref (addresses);

    return email;
}
Exemple #5
0
static void collect_addresses_into(InternetAddressList *ilist, AddressesList *addr_list, guint size) {
  g_return_if_fail(ilist != NULL);
  g_return_if_fail(addr_list != NULL);
  g_return_if_fail(size != 0);

  guint i;
  for (i = 0; i < size; i++) {
    InternetAddress *address = internet_address_list_get_address(ilist, i); // transfer none

    if (INTERNET_ADDRESS_IS_GROUP(address)) {
      InternetAddressGroup *group = INTERNET_ADDRESS_GROUP(address);
      InternetAddressList *group_list = internet_address_group_get_members(group); // transer none

      if (group_list) {
        guint gsize = internet_address_list_length(group_list);
        if (gsize)
          collect_addresses_into(group_list, addr_list, gsize);
      }

    } else if (INTERNET_ADDRESS_IS_MAILBOX(address)) {
      InternetAddressMailbox *mailbox = INTERNET_ADDRESS_MAILBOX(address);
      const gchar *name    = internet_address_get_name(address);
      const gchar *address = internet_address_mailbox_get_addr(mailbox);
      Address *addr = new_address(address, name);
      addresses_list_add(addr_list, addr);
    }
  }
}
Exemple #6
0
/* Scan addresses in 'list'.
 *
 * If 'message' is non-NULL, then 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'.
 *
 * If 'user_from' is non-NULL and *user_from is NULL, *user_from will
 * be set to the first address encountered in 'list' that is the
 * user's address.
 *
 * Return the number of addresses added to 'message'. (If 'message' is
 * NULL, the function returns 0 by definition.)
 */
static unsigned int
scan_address_list (InternetAddressList *list,
		   notmuch_config_t *config,
		   GMimeMessage *message,
		   GMimeRecipientType type,
		   const char **user_from)
{
    InternetAddress *address;
    int i;
    unsigned int n = 0;

    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;

	    n += scan_address_list (group_list, config, message, type, user_from);
	} 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);

	    if (address_is_users (addr, config)) {
		if (user_from && *user_from == NULL)
		    *user_from = addr;
	    } else if (message) {
		g_mime_message_add_recipient (message, type, name, addr);
		n++;
	    }
	}
    }

    return n;
}
Exemple #7
0
/* 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 *
add_recipients_for_address_list (GMimeMessage *message,
				 notmuch_config_t *config,
				 GMimeRecipientType type,
				 InternetAddressList *list)
{
    InternetAddress *address;
    int i;
    const char *ret = NULL;

    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;

	    add_recipients_for_address_list (message, config,
					     type, group_list);
	} 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);

	    if (address_is_users (addr, config)) {
		if (ret == NULL)
		    ret = addr;
	    } else {
		g_mime_message_add_recipient (message, type, name, addr);
	    }
	}
    }

    return ret;
}
Exemple #8
0
/* Print or prepare for printing addresses from InternetAddressList. */
static void
process_address_list (const search_context_t *ctx,
		      InternetAddressList *list)
{
    InternetAddress *address;
    int i;

    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;

	    process_address_list (ctx, group_list);
	} else {
	    InternetAddressMailbox *mailbox = INTERNET_ADDRESS_MAILBOX (address);
	    mailbox_t mbx = {
		.name = internet_address_get_name (address),
		.addr = internet_address_mailbox_get_addr (mailbox),
	    };

	    /* OUTPUT_COUNT only works with deduplication */
	    if (ctx->dedup != DEDUP_NONE &&
		is_duplicate (ctx, mbx.name, mbx.addr))
		continue;

	    /* OUTPUT_COUNT and DEDUP_ADDRESS require a full pass. */
	    if (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS)
		continue;

	    print_mailbox (ctx, &mbx);
	}
    }
}
Exemple #9
0
static void
json_add_address (JsonBuilder *builder, InternetAddress *ia)
{
        if (INTERNET_ADDRESS_IS_GROUP(ia)) {
    InternetAddressGroup *group;
    InternetAddressList *group_list;

    group = INTERNET_ADDRESS_GROUP(ia);
    group_list = internet_address_group_get_members(group);

    json_add_address_list(builder, group_list);
        } else if (INTERNET_ADDRESS_IS_MAILBOX(ia)) {
    InternetAddressMailbox *mailbox;
    const char *addr_name;
    const char *addr_address;

    mailbox = INTERNET_ADDRESS_MAILBOX(ia);
    addr_name = internet_address_get_name(ia);
        addr_address = internet_address_mailbox_get_addr(mailbox);

        if (!addr_name && !addr_address)
                return;

        json_builder_begin_object (builder);

    if (addr_name) {
                json_builder_set_member_name (builder, "name");
                json_builder_add_string_value (builder, addr_name);
        }

        if (addr_address) {
                json_builder_set_member_name (builder, "address");
                json_builder_add_string_value (builder, addr_address);
        }

        json_builder_end_object (builder);
  }
}
Exemple #10
0
static void
vevent_reply(GObject * button, GtkWidget * box)
{
    LibBalsaVEvent *event =
	LIBBALSA_VEVENT(g_object_get_data(button, "event"));
    LibBalsaVCalPartStat pstat =
	GPOINTER_TO_INT(g_object_get_data(button, "mode"));
    gchar *rcpt;
    LibBalsaMessage *message;
    LibBalsaMessageBody *body;
    gchar *dummy;
    gchar **params;
    GError *error = NULL;
    LibBalsaMsgCreateResult result;
    LibBalsaIdentity *ident;

    g_return_if_fail(event != NULL);
    rcpt = (gchar *) g_object_get_data(G_OBJECT(event), "ev:sender");
    g_return_if_fail(rcpt != NULL);
    ident = g_object_get_data(G_OBJECT(event), "ev:ident");
    g_return_if_fail(ident != NULL);

    /* make the button box insensitive... */
    gtk_widget_set_sensitive(box, FALSE);

    /* create a message with the header set from the incoming message */
    message = libbalsa_message_new();
    message->headers->from = internet_address_list_new();
    internet_address_list_add(message->headers->from, ident->ia);
    message->headers->to_list = internet_address_list_parse_string(rcpt);
    message->headers->date = time(NULL);

    /* create the message subject */
    dummy = g_strdup_printf("%s: %s",
			    event->summary ? event->summary : _("iTIP Calendar Request"),
			    libbalsa_vcal_part_stat_to_str(pstat));
    libbalsa_message_set_subject(message, dummy);
    g_free(dummy);

    /* the only message part is the calendar object */
    body = libbalsa_message_body_new(message);
    body->buffer =
	libbalsa_vevent_reply(event,
			      INTERNET_ADDRESS_MAILBOX(ident->ia)->addr,
			      pstat);
    body->charset = g_strdup("utf-8");
    body->content_type = g_strdup("text/calendar");
    libbalsa_message_append_part(message, body);

    /* set the text/calendar parameters */
    params = g_new(gchar *, 3);
    params[0] = g_strdup("method");
    params[1] = g_strdup("reply");
    params[2] = NULL;
    message->parameters = g_list_prepend(message->parameters, params);

#if ENABLE_ESMTP
    result = libbalsa_message_send(message, balsa_app.outbox, NULL,
				   balsa_find_sentbox_by_url,
				   ident->smtp_server,
                                   GTK_WINDOW(gtk_widget_get_toplevel
                                              ((GtkWidget *) button)),
				   FALSE, balsa_app.debug, &error);
#else
    result = libbalsa_message_send(message, balsa_app.outbox, NULL,
				   balsa_find_sentbox_by_url,
                                   GTK_WINDOW(gtk_widget_get_toplevel
                                              ((GtkWidget *) button)),
				   FALSE, balsa_app.debug, &error);
#endif
    if (result != LIBBALSA_MESSAGE_CREATE_OK)
	libbalsa_information(LIBBALSA_INFORMATION_ERROR,
			     _("Sending the iTIP calendar reply failed: %s"),
			     error ? error->message : "?");
    if (error)
	g_error_free(error);
    g_object_unref(G_OBJECT(message));
}
Exemple #11
0
static int
display_message_list (SpruceFolder *folder, GPtrArray *uids, int first, int last, int cursor)
{
	char padding[40];
	char flag;
	char cur;
	int i;
	
	fprintf (stdout, "%s: %d messages, %d new\n", folder->name,
		 spruce_folder_get_message_count (folder),
		 spruce_folder_get_unread_message_count (folder));
	
	memset (padding, ' ', sizeof (padding) - 1);
	padding[sizeof (padding) - 1] = '\0';
	
	for (i = first; i < last; i++) {
		SpruceMessageInfo *info;
		
		if ((info = spruce_folder_get_message_info (folder, uids->pdata[i]))) {
			char *from, frombuf[21], date[17];
			int subjlen, fromlen, frommax, n;
			InternetAddressList *list;
			InternetAddress *ia;
			
			if ((list = internet_address_list_parse_string (info->from))) {
				ia = internet_address_list_get_address (list, 0);
				if (INTERNET_ADDRESS_IS_MAILBOX (ia))
					from = INTERNET_ADDRESS_MAILBOX (ia)->addr;
				else
					from = ia->name;
			} else
				from = "";
			
			strftime (date, sizeof (date), "%a %b %e %H:%M", localtime (&info->date_sent));
			
			frommax = 20;
			if ((n = num_digits (i + 1)) > 2) {
				/*fprintf (stderr, "%d > 2 digits (%d digits)\n", i + 1, n);*/
				frommax -= n - 2;
			}
			
			fromlen = MIN (frommax, strlen (from));
			memcpy (frombuf, from, fromlen);
			for (n = 0; n < fromlen; n++)
				if (!isprint (frombuf[n]))
					frombuf[n] = 'x';
			
			while (fromlen < frommax)
				frombuf[fromlen++] = ' ';
			frombuf[fromlen] = '\0';
			
			subjlen = 23;
			if ((n = (num_digits (info->lines))) > 2)
				subjlen -= n - 2;
			if ((n = (num_digits (info->size))) > 4)
				subjlen -= n - 4;
			
			if ((info->flags & SPRUCE_MESSAGE_DELETED))
				flag = 'D';
			else if ((info->flags & SPRUCE_MESSAGE_ANSWERED))
				flag = 'A';
			else if ((info->flags & SPRUCE_MESSAGE_SEEN))
				flag = 'O';
			else if ((info->flags & SPRUCE_MESSAGE_RECENT))
				flag = 'N';
			else
				flag = 'U';
			
			if ((cursor >= 0 && cursor == i) || (cursor == -1 && flag == 'N')) {
				cursor = i;
				cur = '>';
			} else
				cur = ' ';
			
			fprintf (stdout, "%c%c %s%d %s  %.16s  %.2u/%.4zu  %.*s\n",
				 cur, flag, (i + 1) < 10 ? " " : "", i + 1, frombuf,
				 date, info->lines, info->size, subjlen,
				 info->subject ? info->subject : EMPTY_SUBJECT);
			
			g_object_unref (list);
			
			spruce_folder_free_message_info (folder, info);
		}
	}
	
	return cursor == -1 ? first : cursor;
}