+++ /dev/null
-#!/usr/bin/env python
-"""This is a notmuch implementation in python.
-It's goal is to allow running the test suite on the cnotmuch python bindings.
-
-This "binary" honors the NOTMUCH_CONFIG environmen variable for reading a user's
-notmuch configuration (e.g. the database path).
-
- (c) 2010 by Sebastian Spaeth <Sebastian@SSpaeth.de>
- Jesse Rosenthal <jrosenthal@jhu.edu>
- This code is licensed under the GNU GPL v3+.
-"""
-import sys
-import os
-
-import re
-import stat
-import email
-
-from notmuch import Database, Query, NotmuchError, STATUS
-try:
- # python3.x
- from configparser import SafeConfigParser
-except ImportError:
- # python2.x
- from ConfigParser import SafeConfigParser
-from cStringIO import StringIO
-
-PREFIX = re.compile('(\w+):(.*$)')
-
-HELPTEXT = """The notmuch mail system.
-Usage: notmuch <command> [args...]
-
-Where <command> and [args...] are as follows:
- setup Interactively setup notmuch for first use.
- new [--verbose]
- Find and import new messages to the notmuch database.
- search [options...] <search-terms> [...]
- Search for messages matching the given search terms.
- show <search-terms> [...]
- Show all messages matching the search terms.
- count <search-terms> [...]
- Count messages matching the search terms.
- reply [options...] <search-terms> [...]
- Construct a reply template for a set of messages.
- tag +<tag>|-<tag> [...] [--] <search-terms> [...]
- Add/remove tags for all messages matching the search terms.
- dump [<filename>]
- Create a plain-text dump of the tags for each message.
- restore <filename>
- Restore the tags from the given dump file (see 'dump').
- search-tags [<search-terms> [...] ]
- List all tags found in the database or matching messages.
- help [<command>]
- This message, or more detailed help for the named command.
-
-Use "notmuch help <command>" for more details on each command.
-And "notmuch help search-terms" for the common search-terms syntax.
-"""
-
-USAGE = """Notmuch is configured and appears to have a database. Excellent!
-
-At this point you can start exploring the functionality of notmuch by
-using commands such as:
- notmuch search tag:inbox
- notmuch search to:"%(fullname)s"
- notmuch search from:"%(mailaddress)s"
- notmuch search subject:"my favorite things"
-
-See "notmuch help search" for more details.
-
-You can also use "notmuch show" with any of the thread IDs resulting
-from a search. Finally, you may want to explore using a more sophisticated
-interface to notmuch such as the emacs interface implemented in notmuch.el
-or any other interface described at http://notmuchmail.org
-
-And don't forget to run "notmuch new" whenever new mail arrives.
-
-Have fun, and may your inbox never have much mail.
-"""
-
-#-------------------------------------------------------------------------
-def quote_query_line(argv):
- # mangle arguments wrapping terms with spaces in quotes
- for (num, item) in enumerate(argv):
- if item.find(' ') >= 0:
- # if we use prefix:termWithSpaces, put quotes around term
- match = PREFIX.match(item)
- if match:
- argv[num] = '%s:"%s"' %(match.group(1), match.group(2))
- else:
- argv[num] = '"%s"' % item
- return ' '.join(argv)
-
-#-------------------------------------------------------------------------
-
-
-class Notmuch(object):
-
- def __init__(self, configpath="~/.notmuch-config)"):
- self._config = None
- self._configpath = os.getenv('NOTMUCH_CONFIG',
- os.path.expanduser(configpath))
-
- def cmd_usage(self):
- """Print the usage text and exits"""
- data={}
- names = self.get_user_email_addresses()
- data['fullname'] = names[0] if names[0] else 'My Name'
- data['mailaddress'] = names[1] if names[1] else 'My@email.address'
- print USAGE % data
-
- def cmd_new(self):
- """Run 'notmuch new'"""
- #get the database directory
- db = Database(mode=Database.MODE.READ_WRITE)
- path = db.get_path()
- print self._add_new_files_recursively(path, db)
-
- def cmd_help(self, subcmd=None):
- """Print help text for 'notmuch help'"""
- if len(subcmd) > 1:
- print "Help for specific commands not implemented"
- return
- print HELPTEXT
-
- def _get_user_notmuch_config(self):
- """Returns the ConfigParser of the user's notmuch-config"""
- # return the cached config parser if we read it already
- if self._config:
- return self._config
-
- config = SafeConfigParser()
- config.read(self._configpath)
- self._config = config
- return config
-
- def _add_new_files_recursively(self, path, db):
- """:returns: (added, moved, removed)"""
- print "Enter add new files with path %s" % path
-
- try:
- #get the Directory() object for this path
- db_dir = db.get_directory(path)
- added = moved = removed = 0
- except NotmuchError:
- # Occurs if we have wrong absolute paths in the db, for example
- return (0,0,0)
-
-
- # for folder in subdirs:
-
- # TODO, retrieve dir mtime here and store it later
- # as long as Filenames() does not allow multiple iteration, we need to
- # use this kludgy way to get a sorted list of filenames
- # db_files is a list of subdirectories and filenames in this folder
- db_files = set()
- db_folders = set()
- for subdir in db_dir.get_child_directories():
- db_folders.add(subdir)
-# file is a keyword (remove this ;))
- for mail in db_dir.get_child_files():
- db_files.add(mail)
-
- fs_files = set(os.listdir(db_dir.path))
-
- # list of files (and folders) on the fs, but not the db
- for fs_file in ((fs_files - db_files) - db_folders):
- absfile = os.path.normpath(os.path.join(db_dir.path, fs_file))
- statinfo = os.stat(absfile)
-
- if stat.S_ISDIR(statinfo.st_mode):
- # This is a directory
- if fs_file in ['.notmuch','tmp','.']:
- continue
- print "%s %s" % (fs_file, db_folders)
- print "Directory not in db yet. Descending into %s" % absfile
- new = self._add_new_files_recursively(absfile, db)
- added += new[0]
- moved += new[1]
- removed += new[2]
-
- elif stat.S_ISLNK(statinfo.st_mode):
- print ("%s is a symbolic link (%d). FIXME!!!" %
- (absfile, statinfo.st_mode))
- exit(1)
-
- else:
- # This is a regular file, not in the db yet. Add it.
- print "This file needs to be added %s" % (absfile)
- (msg, status) = db.add_message(absfile)
- # We increases 'added', even on dupe messages. If it is a moved
- # message, we will deduct it later and increase 'moved' instead
- added += 1
-
- if status == STATUS.DUPLICATE_MESSAGE_ID:
- print "Added msg was in the db"
- else:
- print "New message."
-
- # Finally a list of files (not folders) in the database,
- # but not the filesystem
- for db_file in (db_files - fs_files):
- absfile = os.path.normpath(os.path.join(db_dir.path, db_file))
-
- # remove a mail message from the db
- print ("%s is not on the fs anymore. Delete" % absfile)
- status = db.remove_message(absfile)
-
- if status == STATUS.SUCCESS:
- # we just deleted the last reference, so this was a remove
- removed += 1
- sys.stderr.write("SUCCESS %d %s %s.\n" %
- (status, STATUS.status2str(status), absfile))
- elif status == STATUS.DUPLICATE_MESSAGE_ID:
- # The filename exists already somewhere else, so this is a move
- moved += 1
- added -= 1
- sys.stderr.write("DUPE %d %s %s.\n" %
- (status, STATUS.status2str(status), absfile))
- else:
- # This should not occur
- sys.stderr.write("This should not occur %d %s %s.\n" %
- (status, STATUS.status2str(status), absfile))
-
- # list of folders in the filesystem. Just descend into dirs
- for fs_file in fs_files:
- absfile = os.path.normpath(os.path.join(db_dir.path, fs_file))
- if os.path.isdir(absfile):
- # This is a directory. Remove it from the db_folder list.
- # All remaining db_folders at the end will be not present
- # on the file system.
- db_folders.remove(fs_file)
- if fs_file in ['.notmuch','tmp','.']:
- continue
- new = self._add_new_files_recursively(absfile, db)
- added += new[0]
- moved += new[0]
- removed += new[0]
-
- # we are not interested in anything but directories here
- #TODO: All remaining elements of db_folders are not in the filesystem
- #delete those
-
- return added, moved, removed
- #Read the mtime of a directory from the filesystem
- #
- #* Call :meth:`Database.add_message` for all mail files in
- # the directory
-
- #* Call notmuch_directory_set_mtime with the mtime read from the
- # filesystem. Then, when wanting to check for updates to the
- # directory in the future, the client can call :meth:`get_mtime`
- # and know that it only needs to add files if the mtime of the
- # directory and files are newer than the stored timestamp.
-
- def get_user_email_addresses(self):
- """ Reads a user's notmuch config and returns his email addresses as
- list (name, primary_address, other_address1,...)"""
-
- #read the config file
- config = self._get_user_notmuch_config()
-
- conf = {'name': '', 'primary_email': ''}
- for entry in conf:
- if config.has_option('user', entry):
- conf[entry] = config.get('user', entry)
-
- if config.has_option('user','other_email'):
- other = config.get('user','other_email')
- other = [mail.strip() for mail in other.split(';') if mail]
- else:
- other = []
- # for being compatible. It would be nicer to return a dict.
- return conf.keys() + other
-
- def quote_msg_body(self, oldbody ,date, from_address):
- """Transform a mail body into a quoted text,
- starting with On foo, bar wrote:
-
- :param body: a str with a mail body
- :returns: The new payload of the email.message()
- """
-
- # we get handed a string, wrap it in a file-like object
- oldbody = StringIO(oldbody)
- newbody = StringIO()
-
- newbody.write("On %s, %s wrote:\n" % (date, from_address))
-
- for line in oldbody:
- newbody.write("> " + line)
-
- return newbody.getvalue()
-
- def format_reply(self, msgs):
- """Gets handed Messages() and displays the reply to them
-
- This is pretty ugly and hacky. It tries to mimic the "real"
- notmuch output as much as it can to pass the test suite. It
- could deserve a healthy bit of love. It is also buggy because
- it returns after the first message it has handled."""
-
- for msg in msgs:
- f = open(msg.get_filename(), "r")
- reply = email.message_from_file(f)
-
- # handle the easy non-multipart case:
- if not reply.is_multipart():
- reply.set_payload(self.quote_msg_body(reply.get_payload(),
- reply['date'], reply['from']))
- else:
- # handle the tricky multipart case
- deleted = ""
- """A string describing which nontext attachements
- that have been deleted"""
- delpayloads = []
- """A list of payload indices to be deleted"""
- payloads = reply.get_payload()
-
- for (num, part) in enumerate(payloads):
- mime_main = part.get_content_maintype()
- if mime_main not in ['multipart', 'message', 'text']:
- deleted += "Non-text part: %s\n" % (part.get_content_type())
- payloads[num].set_payload("Non-text part: %s" %
- (part.get_content_type()))
- payloads[num].set_type('text/plain')
- delpayloads.append(num)
- elif mime_main == 'text':
- payloads[num].set_payload(self.quote_msg_body(
- payloads[num].get_payload(),
- reply['date'], reply['from']))
- else:
- # TODO handle deeply nested multipart messages
- sys.stderr.write ("FIXME: Ignoring multipart part. Handle me\n")
- # Delete those payloads that we don't need anymore
- for item in reversed(sorted(delpayloads)):
- del payloads[item]
-
- # Back to single- and multipart handling
- my_addresses = self.get_user_email_addresses()
- used_address = None
- # filter our email addresses from all to: cc: and bcc: fields
- # if we find one of "my" addresses being used,
- # it is stored in used_address
- for header in ['To', 'CC', 'Bcc']:
- if not header in reply:
- #only handle fields that exist
- continue
- addresses = email.utils.getaddresses(reply.get_all(header, []))
- purged_addr = []
- for (name, mail) in addresses:
- if mail in my_addresses[1:]:
- used_address = email.utils.formataddr(
- (my_addresses[0], mail))
- else:
- purged_addr.append(email.utils.formataddr((name, mail)))
-
- if purged_addr:
- reply.replace_header(header, ", ".join(purged_addr))
- else:
- # we deleted all addresses, delete the header
- del reply[header]
-
- # Use our primary email address to the From
- # (save original from line, we still need it)
- new_to = reply['From']
- if used_address:
- reply['From'] = used_address
- else:
- email.utils.formataddr((my_addresses[0], my_addresses[1]))
-
- reply['Subject'] = 'Re: ' + reply['Subject']
-
- # Calculate our new To: field
- # add all remaining original 'To' addresses
- if 'To' in reply:
- new_to += ", " + reply['To']
- reply.add_header('To', new_to)
-
- # Add our primary email address to the BCC
- new_bcc = my_addresses[1]
- if 'Bcc' in reply:
- new_bcc += ', ' + reply['Bcc']
- reply['Bcc'] = new_bcc
-
- # Set replies 'In-Reply-To' header to original's Message-ID
- if 'Message-ID' in reply:
- reply['In-Reply-To'] = reply['Message-ID']
-
- #Add original's Message-ID to replies 'References' header.
- if 'References' in reply:
- reply['References'] = ' '.join([reply['References'], reply['Message-ID']])
- else:
- reply['References'] = reply['Message-ID']
-
- # Delete the original Message-ID.
- del(reply['Message-ID'])
-
- # filter all existing headers but a few and delete them from 'reply'
- delheaders = filter(lambda x: x not in ['From', 'To', 'Subject', 'CC',
- 'Bcc', 'In-Reply-To',
- 'References', 'Content-Type'],
- reply.keys())
- map(reply.__delitem__, delheaders)
-
- # TODO: OUCH, we return after the first msg we have handled rather than
- # handle all of them
- # return resulting message without Unixfrom
- return reply.as_string(False)
-
-
-def main():
- # Handle command line options
- #------------------------------------
- # No option given, print USAGE and exit
- if len(sys.argv) == 1:
- Notmuch().cmd_usage()
- #------------------------------------
- elif sys.argv[1] == 'setup':
- """Interactively setup notmuch for first use."""
- exit("Not implemented.")
- #-------------------------------------
- elif sys.argv[1] == 'new':
- """Check for new and removed messages."""
- Notmuch().cmd_new()
- #-------------------------------------
- elif sys.argv[1] == 'help':
- """Print the help text"""
- Notmuch().cmd_help(sys.argv[1:])
- #-------------------------------------
- elif sys.argv[1] == 'part':
- part()
- #-------------------------------------
- elif sys.argv[1] == 'search':
- search()
- #-------------------------------------
- elif sys.argv[1] == 'show':
- show()
- #-------------------------------------
- elif sys.argv[1] == 'reply':
- db = Database()
- if len(sys.argv) == 2:
- # no search term. abort
- exit("Error: notmuch reply requires at least one search term.")
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[2:])
- msgs = Query(db, querystr).search_messages()
- print Notmuch().format_reply(msgs)
- #-------------------------------------
- elif sys.argv[1] == 'count':
- if len(sys.argv) == 2:
- # no further search term, count all
- querystr = ''
- else:
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[2:])
- print Database().create_query(querystr).count_messages()
- #-------------------------------------
- elif sys.argv[1] == 'tag':
- # build lists of tags to be added and removed
- add = []
- remove = []
- while not sys.argv[2] == '--' and \
- (sys.argv[2].startswith('+') or sys.argv[2].startswith('-')):
- if sys.argv[2].startswith('+'):
- # append to add list without initial +
- add.append(sys.argv.pop(2)[1:])
- else:
- # append to remove list without initial -
- remove.append(sys.argv.pop(2)[1:])
- # skip eventual '--'
- if sys.argv[2] == '--': sys.argv.pop(2)
- # the rest is search terms
- querystr = quote_query_line(sys.argv[2:])
- db = Database(mode=Database.MODE.READ_WRITE)
- msgs = Query(db, querystr).search_messages()
- for msg in msgs:
- # actually add and remove all tags
- map(msg.add_tag, add)
- map(msg.remove_tag, remove)
- #-------------------------------------
- elif sys.argv[1] == 'search-tags':
- if len(sys.argv) == 2:
- # no further search term
- print "\n".join(Database().get_all_tags())
- else:
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[2:])
- db = Database()
- msgs = Query(db, querystr).search_messages()
- print "\n".join([t for t in msgs.collect_tags()])
- #-------------------------------------
- elif sys.argv[1] == 'dump':
- if len(sys.argv) == 2:
- f = sys.stdout
- else:
- f = open(sys.argv[2], "w")
- db = Database()
- query = Query(db, '')
- query.set_sort(Query.SORT.MESSAGE_ID)
- msgs = query.search_messages()
- for msg in msgs:
- f.write("%s (%s)\n" % (msg.get_message_id(), msg.get_tags()))
- #-------------------------------------
- elif sys.argv[1] == 'restore':
- if len(sys.argv) == 2:
- print("No filename given. Reading dump from stdin.")
- f = sys.stdin
- else:
- f = open(sys.argv[2], "r")
-
- # split the msg id and the tags
- MSGID_TAGS = re.compile("(\S+)\s\((.*)\)$")
- db = Database(mode=Database.MODE.READ_WRITE)
-
- #read each line of the dump file
- for line in f:
- msgs = MSGID_TAGS.match(line)
- if not msgs:
- sys.stderr.write("Warning: Ignoring invalid input line: %s" %
- line)
- continue
- # split line in components and fetch message
- msg_id = msgs.group(1)
- new_tags = set(msgs.group(2).split())
- msg = db.find_message(msg_id)
-
- if msg == None:
- sys.stderr.write(
- "Warning: Cannot apply tags to missing message: %s\n" % msg_id)
- continue
-
- # do nothing if the old set of tags is the same as the new one
- old_tags = set(msg.get_tags())
- if old_tags == new_tags: continue
-
- # set the new tags
- msg.freeze()
- # only remove tags if the new ones are not a superset anyway
- if not (new_tags > old_tags): msg.remove_all_tags()
- for tag in new_tags: msg.add_tag(tag)
- msg.thaw()
- #-------------------------------------
- else:
- # unknown command
- exit("Error: Unknown command '%s' (see \"notmuch help\")" % sys.argv[1])
-
-def part():
- db = Database()
- query_string = ''
- part_num = 0
- first_search_term = 0
- for (num, arg) in enumerate(sys.argv[1:]):
- if arg.startswith('--part='):
- part_num_str = arg.split("=")[1]
- try:
- part_num = int(part_num_str)
- except ValueError:
- # just emulating behavior
- exit(1)
- elif not arg.startswith('--'):
- # save the position of the first sys.argv
- # that is a search term
- first_search_term = num + 1
- if first_search_term:
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[first_search_term:])
- qry = Query(db,querystr)
- msgs = [msg for msg in qry.search_messages()]
-
- if not msgs:
- sys.exit(1)
- elif len(msgs) > 1:
- raise Exception("search term did not match precisely one message")
- else:
- msg = msgs[0]
- print msg.get_part(part_num)
-
-def search():
- db = Database()
- query_string = ''
- sort_order = "newest-first"
- first_search_term = 0
- for (num, arg) in enumerate(sys.argv[1:]):
- if arg.startswith('--sort='):
- sort_order=arg.split("=")[1]
- if not sort_order in ("oldest-first", "newest-first"):
- raise Exception("unknown sort order")
- elif not arg.startswith('--'):
- # save the position of the first sys.argv that is a search term
- first_search_term = num + 1
-
- if first_search_term:
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[first_search_term:])
-
- qry = Query(db, querystr)
- if sort_order == "oldest-first":
- qry.set_sort(Query.SORT.OLDEST_FIRST)
- else:
- qry.set_sort(Query.SORT.NEWEST_FIRST)
- threads = qry.search_threads()
-
- for thread in threads:
- print thread
-
-def show():
- entire_thread = False
- db = Database()
- out_format = "text"
- querystr = ''
- first_search_term = None
-
- # ugly homegrown option parsing
- # TODO: use OptionParser
- for (num, arg) in enumerate(sys.argv[1:]):
- if arg == '--entire-thread':
- entire_thread = True
- elif arg.startswith("--format="):
- out_format = arg.split("=")[1]
- if out_format == 'json':
- # for compatibility use --entire-thread for json
- entire_thread = True
- if not out_format in ("json", "text"):
- raise Exception("unknown format")
- elif not arg.startswith('--'):
- # save the position of the first sys.argv that is a search term
- first_search_term = num + 1
-
- if first_search_term:
- # mangle arguments wrapping terms with spaces in quotes
- querystr = quote_query_line(sys.argv[first_search_term:])
-
- threads = Query(db, querystr).search_threads()
- first_toplevel = True
- if out_format == "json":
- sys.stdout.write("[")
- for thread in threads:
- msgs = thread.get_toplevel_messages()
- if not first_toplevel:
- if out_format == "json":
- sys.stdout.write(", ")
- first_toplevel = False
- msgs.print_messages(out_format, 0, entire_thread)
-
- if out_format == "json":
- sys.stdout.write("]")
- sys.stdout.write("\n")
-
-if __name__ == '__main__':
- main()
from .filenames import Filenames
import email
-try:
- import simplejson as json
-except ImportError:
- import json
class Message(Python3StringMixIn):
raise NotInitializedError()
tags_p = Message._get_tags(self._msg)
- if tags_p == None:
+ if not tags_p:
raise NullPointerError()
return Tags(tags_p, self)
out_part = parts[(num - 1)]
return out_part.get_payload(decode=True)
- def format_message_internal(self):
- """Create an internal representation of the message parts,
- which can easily be output to json, text, or another output
- format. The argument match tells whether this matched a
- query.
-
- .. deprecated:: 0.13
- This code adds functionality at the python
- level that is unlikely to be useful for
- anyone. Furthermore the python bindings strive
- to be a thin wrapper around libnotmuch, so
- this code will be removed in notmuch 0.14.
- """
- output = {}
- output["id"] = self.get_message_id()
- output["match"] = self.is_match()
- output["filename"] = self.get_filename()
- output["tags"] = list(self.get_tags())
-
- headers = {}
- for h in ["Subject", "From", "To", "Cc", "Bcc", "Date"]:
- headers[h] = self.get_header(h)
- output["headers"] = headers
-
- body = []
- parts = self.get_message_parts()
- for i in xrange(len(parts)):
- msg = parts[i]
- part_dict = {}
- part_dict["id"] = i + 1
- # We'll be using this is a lot, so let's just get it once.
- cont_type = msg.get_content_type()
- part_dict["content-type"] = cont_type
- # NOTE:
- # Now we emulate the current behaviour, where it ignores
- # the html if there's a text representation.
- #
- # This is being worked on, but it will be easier to fix
- # here in the future than to end up with another
- # incompatible solution.
- disposition = msg["Content-Disposition"]
- if disposition and disposition.lower().startswith("attachment"):
- part_dict["filename"] = msg.get_filename()
- else:
- if cont_type.lower() == "text/plain":
- part_dict["content"] = msg.get_payload()
- elif (cont_type.lower() == "text/html" and
- i == 0):
- part_dict["content"] = msg.get_payload()
- body.append(part_dict)
-
- output["body"] = body
-
- return output
-
- def format_message_as_json(self, indent=0):
- """Outputs the message as json. This is essentially the same
- as python's dict format, but we run it through, just so we
- don't have to worry about the details.
-
- .. deprecated:: 0.13
- This code adds functionality at the python
- level that is unlikely to be useful for
- anyone. Furthermore the python bindings strive
- to be a thin wrapper around libnotmuch, so
- this code will be removed in notmuch 0.14.
- """
- return json.dumps(self.format_message_internal())
-
- def format_message_as_text(self, indent=0):
- """Outputs it in the old-fashioned notmuch text form. Will be
- easy to change to a new format when the format changes.
-
- .. deprecated:: 0.13
- This code adds functionality at the python
- level that is unlikely to be useful for
- anyone. Furthermore the python bindings strive
- to be a thin wrapper around libnotmuch, so
- this code will be removed in notmuch 0.14.
- """
-
-
- format = self.format_message_internal()
- output = "\fmessage{ id:%s depth:%d match:%d filename:%s" \
- % (format['id'], indent, format['match'], format['filename'])
- output += "\n\fheader{"
-
- #Todo: this date is supposed to be prettified, as in the index.
- output += "\n%s (%s) (" % (format["headers"]["From"],
- format["headers"]["Date"])
- output += ", ".join(format["tags"])
- output += ")"
-
- output += "\nSubject: %s" % format["headers"]["Subject"]
- output += "\nFrom: %s" % format["headers"]["From"]
- output += "\nTo: %s" % format["headers"]["To"]
- if format["headers"]["Cc"]:
- output += "\nCc: %s" % format["headers"]["Cc"]
- if format["headers"]["Bcc"]:
- output += "\nBcc: %s" % format["headers"]["Bcc"]
- output += "\nDate: %s" % format["headers"]["Date"]
- output += "\n\fheader}"
-
- output += "\n\fbody{"
-
- parts = format["body"]
- parts.sort(key=lambda x: x['id'])
- for p in parts:
- if not "filename" in p:
- output += "\n\fpart{ "
- output += "ID: %d, Content-type: %s\n" % (p["id"],
- p["content-type"])
- if "content" in p:
- output += "\n%s\n" % p["content"]
- else:
- output += "Non-text part: %s\n" % p["content-type"]
- output += "\n\fpart}"
- else:
- output += "\n\fattachment{ "
- output += "ID: %d, Content-type:%s\n" % (p["id"],
- p["content-type"])
- output += "Attachment: %s\n" % p["filename"]
- output += "\n\fattachment}\n"
-
- output += "\n\fbody}\n"
- output += "\n\fmessage}"
-
- return output
-
def __hash__(self):
"""Implement hash(), so we can use Message() sets"""
file = self.get_filename()
format_part_reply (mime_node_child (node, i));
}
-/* 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)
+typedef enum {
+ USER_ADDRESS_IN_STRING,
+ STRING_IN_USER_ADDRESS,
+ STRING_IS_USER_ADDRESS,
+} address_match_t;
+
+/* Match given string against given address according to mode. */
+static notmuch_bool_t
+match_address (const char *str, const char *address, address_match_t mode)
+{
+ switch (mode) {
+ case USER_ADDRESS_IN_STRING:
+ return strcasestr (str, address) != NULL;
+ case STRING_IN_USER_ADDRESS:
+ return strcasestr (address, str) != NULL;
+ case STRING_IS_USER_ADDRESS:
+ return strcasecmp (address, str) == 0;
+ }
+
+ return FALSE;
+}
+
+/* Match given string against user's configured "primary" and "other"
+ * addresses according to mode. */
+static const char *
+address_match (const char *str, notmuch_config_t *config, address_match_t mode)
{
const char *primary;
const char **other;
size_t i, other_len;
+ if (!str || *str == '\0')
+ return NULL;
+
primary = notmuch_config_get_user_primary_email (config);
- if (strcasecmp (primary, address) == 0)
- return 1;
+ if (match_address (str, primary, mode))
+ return primary;
other = notmuch_config_get_user_other_email (config, &other_len);
- for (i = 0; i < other_len; i++)
- if (strcasecmp (other[i], address) == 0)
- return 1;
+ for (i = 0; i < other_len; i++) {
+ if (match_address (str, other[i], mode))
+ return other[i];
+ }
- return 0;
+ return NULL;
+}
+
+/* Does the given string contain an address configured as one of the
+ * user's "primary" or "other" addresses. If so, return the matching
+ * address, NULL otherwise. */
+static const char *
+user_address_in_string (const char *str, notmuch_config_t *config)
+{
+ return address_match (str, config, USER_ADDRESS_IN_STRING);
+}
+
+/* Do any of the addresses configured as one of the user's "primary"
+ * or "other" addresses contain the given string. If so, return the
+ * matching address, NULL otherwise. */
+static const char *
+string_in_user_address (const char *str, notmuch_config_t *config)
+{
+ return address_match (str, config, STRING_IN_USER_ADDRESS);
+}
+
+/* Is the given address configured as one of the user's "primary" or
+ * "other" addresses. */
+static notmuch_bool_t
+address_is_users (const char *address, notmuch_config_t *config)
+{
+ return address_match (address, config, STRING_IS_USER_ADDRESS) != NULL;
}
/* Scan addresses in 'list'.
static const char *
guess_from_received_header (notmuch_config_t *config, notmuch_message_t *message)
{
- const char *received,*primary,*by;
- const char **other;
- char *tohdr;
+ const char *addr, *received, *by;
char *mta,*ptr,*token;
char *domain=NULL;
char *tld=NULL;
const char *delim=". \t";
- size_t i,j,other_len;
+ size_t i;
const char *to_headers[] = {"Envelope-to", "X-Original-To"};
- primary = notmuch_config_get_user_primary_email (config);
- other = notmuch_config_get_user_other_email (config, &other_len);
-
/* sadly, there is no standard way to find out to which email
* address a mail was delivered - what is in the headers depends
* on the MTAs used along the way. So we are trying a number of
* 'by' part of Received headers
* If none of these work, we give up and return NULL
*/
- for (i = 0; i < sizeof(to_headers)/sizeof(*to_headers); i++) {
- tohdr = xstrdup(notmuch_message_get_header (message, to_headers[i]));
- if (tohdr && *tohdr) {
- /* tohdr is potentialy a list of email addresses, so here we
- * check if one of the email addresses is a substring of tohdr
- */
- if (strcasestr(tohdr, primary)) {
- free(tohdr);
- return primary;
- }
- for (j = 0; j < other_len; j++)
- if (strcasestr (tohdr, other[j])) {
- free(tohdr);
- return other[j];
- }
- free(tohdr);
- }
+ for (i = 0; i < ARRAY_SIZE (to_headers); i++) {
+ const char *tohdr = notmuch_message_get_header (message, to_headers[i]);
+
+ /* Note: tohdr potentially contains a list of email addresses. */
+ addr = user_address_in_string (tohdr, config);
+ if (addr)
+ return addr;
}
/* We get the concatenated Received: headers and search from the
* header
*/
ptr = strstr (received, " for ");
- if (ptr) {
- /* the text following is potentialy a list of email addresses,
- * so again we check if one of the email addresses is a
- * substring of ptr
- */
- if (strcasestr(ptr, primary)) {
- return primary;
- }
- for (i = 0; i < other_len; i++)
- if (strcasestr (ptr, other[i])) {
- return other[i];
- }
- }
+
+ /* Note: ptr potentially contains a list of email addresses. */
+ addr = user_address_in_string (ptr, config);
+ if (addr)
+ return addr;
+
/* Finally, we parse all the " by MTA ..." headers to guess the
* email address that this was originally delivered to.
* We extract just the MTA here by removing leading whitespace and
*/
*(tld-1) = '.';
- if (strcasestr(primary, domain)) {
- free(mta);
- return primary;
+ addr = string_in_user_address (domain, config);
+ if (addr) {
+ free (mta);
+ return addr;
}
- for (i = 0; i < other_len; i++)
- if (strcasestr (other[i],domain)) {
- free(mta);
- return other[i];
- }
}
free (mta);
}
projects / notmuch / commitdiff