roundup/mailgw.py

   1 #
   2 # Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
   3 # This module is free software, and you may redistribute it and/or modify
   4 # under the same terms as Python, so long as this copyright message and
   5 # disclaimer are retained in their original form.
   6 #
   7 # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
   8 # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
   9 # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
  10 # POSSIBILITY OF SUCH DAMAGE.
  11 #
  12 # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  13 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
  15 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
  16 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  17 #
  18
  19 '''
  20 An e-mail gateway for Roundup.
  21
  22 Incoming messages are examined for multiple parts:
  23  . In a multipart/mixed message or part, each subpart is extracted and
  24    examined. The text/plain subparts are assembled to form the textual
  25    body of the message, to be stored in the file associated with a "msg"
  26    class node. Any parts of other types are each stored in separate files
  27    and given "file" class nodes that are linked to the "msg" node.
  28  . In a multipart/alternative message or part, we look for a text/plain
  29    subpart and ignore the other parts.
  30
  31 Summary
  32 -------
  33 The "summary" property on message nodes is taken from the first non-quoting
  34 section in the message body. The message body is divided into sections by
  35 blank lines. Sections where the second and all subsequent lines begin with
  36 a ">" or "|" character are considered "quoting sections". The first line of
  37 the first non-quoting section becomes the summary of the message.
  38
  39 Addresses
  40 ---------
  41 All of the addresses in the To: and Cc: headers of the incoming message are
  42 looked up among the user nodes, and the corresponding users are placed in
  43 the "recipients" property on the new "msg" node. The address in the From:
  44 header similarly determines the "author" property of the new "msg"
  45 node. The default handling for addresses that don't have corresponding
  46 users is to create new users with no passwords and a username equal to the
  47 address. (The web interface does not permit logins for users with no
  48 passwords.) If we prefer to reject mail from outside sources, we can simply
  49 register an auditor on the "user" class that prevents the creation of user
  50 nodes with no passwords.
  51
  52 Actions
  53 -------
  54 The subject line of the incoming message is examined to determine whether
  55 the message is an attempt to create a new item or to discuss an existing
  56 item. A designator enclosed in square brackets is sought as the first thing
  57 on the subject line (after skipping any "Fwd:" or "Re:" prefixes).
  58
  59 If an item designator (class name and id number) is found there, the newly
  60 created "msg" node is added to the "messages" property for that item, and
  61 any new "file" nodes are added to the "files" property for the item.
  62
  63 If just an item class name is found there, we attempt to create a new item
  64 of that class with its "messages" property initialized to contain the new
  65 "msg" node and its "files" property initialized to contain any new "file"
  66 nodes.
  67
  68 Triggers
  69 --------
  70 Both cases may trigger detectors (in the first case we are calling the
  71 set() method to add the message to the item's spool; in the second case we
  72 are calling the create() method to create a new node). If an auditor raises
  73 an exception, the original message is bounced back to the sender with the
  74 explanatory message given in the exception.
  75
  76 $Id: mailgw.py,v 1.99 2002-11-05 22:59:46 richard Exp $
  77 '''
  78
  79 import string, re, os, mimetools, cStringIO, smtplib, socket, binascii, quopri
  80 import time, random, sys
  81 import traceback, MimeWriter
  82 import hyperdb, date, password
  83
  84 SENDMAILDEBUG = os.environ.get('SENDMAILDEBUG', '')
  85
  86 class MailGWError(ValueError):
  87     pass
  88
  89 class MailUsageError(ValueError):
  90     pass
  91
  92 class MailUsageHelp(Exception):
  93     pass
  94
  95 class Unauthorized(Exception):
  96     """ Access denied """
  97
  98 def initialiseSecurity(security):
  99     ''' Create some Permissions and Roles on the security object
 100
 101         This function is directly invoked by security.Security.__init__()
 102         as a part of the Security object instantiation.
 103     '''
 104     security.addPermission(name="Email Registration",
 105         description="Anonymous may register through e-mail")
 106     p = security.addPermission(name="Email Access",
 107         description="User may use the email interface")
 108     security.addPermissionToRole('Admin', p)
 109
 110 class Message(mimetools.Message):
 111     ''' subclass mimetools.Message so we can retrieve the parts of the
 112         message...
 113     '''
 114     def getPart(self):
 115         ''' Get a single part of a multipart message and return it as a new
 116             Message instance.
 117         '''
 118         boundary = self.getparam('boundary')
 119         mid, end = '--'+boundary, '--'+boundary+'--'
 120         s = cStringIO.StringIO()
 121         while 1:
 122             line = self.fp.readline()
 123             if not line:
 124                 break
 125             if line.strip() in (mid, end):
 126                 break
 127             s.write(line)
 128         if not s.getvalue().strip():
 129             return None
 130         s.seek(0)
 131         return Message(s)
 132
 133 subject_re = re.compile(r'(?P<refwd>\s*\W?\s*(fwd|re|aw)\W\s*)*'
 134     r'\s*(?P<quote>")?(\[(?P<classname>[^\d\s]+)(?P<nodeid>\d+)?\])?'
 135     r'\s*(?P<title>[^[]+)?"?(\[(?P<args>.+?)\])?', re.I)
 136
 137 class MailGW:
 138     def __init__(self, instance, db):
 139         self.instance = instance
 140         self.db = db
 141
 142         # should we trap exceptions (normal usage) or pass them through
 143         # (for testing)
 144         self.trapExceptions = 1
 145
 146     def do_pipe(self):
 147         ''' Read a message from standard input and pass it to the mail handler.
 148
 149             Read into an internal structure that we can seek on (in case
 150             there's an error).
 151
 152             XXX: we may want to read this into a temporary file instead...
 153         '''
 154         s = cStringIO.StringIO()
 155         s.write(sys.stdin.read())
 156         s.seek(0)
 157         self.main(s)
 158         return 0
 159
 160     def do_mailbox(self, filename):
 161         ''' Read a series of messages from the specified unix mailbox file and
 162             pass each to the mail handler.
 163         '''
 164         # open the spool file and lock it
 165         import fcntl, FCNTL
 166         f = open(filename, 'r+')
 167         fcntl.flock(f.fileno(), FCNTL.LOCK_EX)
 168
 169         # handle and clear the mailbox
 170         try:
 171             from mailbox import UnixMailbox
 172             mailbox = UnixMailbox(f, factory=Message)
 173             # grab one message
 174             message = mailbox.next()
 175             while message:
 176                 # handle this message
 177                 self.handle_Message(message)
 178                 message = mailbox.next()
 179             # nuke the file contents
 180             os.ftruncate(f.fileno(), 0)
 181         except:
 182             import traceback
 183             traceback.print_exc()
 184             return 1
 185         fcntl.flock(f.fileno(), FCNTL.LOCK_UN)
 186         return 0
 187
 188     def do_pop(self, server, user='', password=''):
 189         '''Read a series of messages from the specified POP server.
 190         '''
 191         import getpass, poplib, socket
 192         try:
 193             if not user:
 194                 user = raw_input(_('User: '))
 195             if not password:
 196                 password = getpass.getpass()
 197         except (KeyboardInterrupt, EOFError):
 198             # Ctrl C or D maybe also Ctrl Z under Windows.
 199             print "\nAborted by user."
 200             return 1
 201
 202         # open a connection to the server and retrieve all messages
 203         try:
 204             server = poplib.POP3(server)
 205         except socket.error, message:
 206             print "POP server error:", message
 207             return 1
 208         server.user(user)
 209         server.pass_(password)
 210         numMessages = len(server.list()[1])
 211         for i in range(1, numMessages+1):
 212             # retr: returns
 213             # [ pop response e.g. '+OK 459 octets',
 214             #   [ array of message lines ],
 215             #   number of octets ]
 216             lines = server.retr(i)[1]
 217             s = cStringIO.StringIO('\n'.join(lines))
 218             s.seek(0)
 219             self.handle_Message(Message(s))
 220             # delete the message
 221             server.dele(i)
 222
 223         # quit the server to commit changes.
 224         server.quit()
 225         return 0
 226
 227     def main(self, fp):
 228         ''' fp - the file from which to read the Message.
 229         '''
 230         return self.handle_Message(Message(fp))
 231
 232     def handle_Message(self, message):
 233         '''Handle an RFC822 Message
 234
 235         Handle the Message object by calling handle_message() and then cope
 236         with any errors raised by handle_message.
 237         This method's job is to make that call and handle any
 238         errors in a sane manner. It should be replaced if you wish to
 239         handle errors in a different manner.
 240         '''
 241         # in some rare cases, a particularly stuffed-up e-mail will make
 242         # its way into here... try to handle it gracefully
 243         sendto = message.getaddrlist('from')
 244         if sendto:
 245             if not self.trapExceptions:
 246                 return self.handle_message(message)
 247             try:
 248                 return self.handle_message(message)
 249             except MailUsageHelp:
 250                 # bounce the message back to the sender with the usage message
 251                 fulldoc = '\n'.join(string.split(__doc__, '\n')[2:])
 252                 sendto = [sendto[0][1]]
 253                 m = ['']
 254                 m.append('\n\nMail Gateway Help\n=================')
 255                 m.append(fulldoc)
 256                 m = self.bounce_message(message, sendto, m,
 257                     subject="Mail Gateway Help")
 258             except MailUsageError, value:
 259                 # bounce the message back to the sender with the usage message
 260                 fulldoc = '\n'.join(string.split(__doc__, '\n')[2:])
 261                 sendto = [sendto[0][1]]
 262                 m = ['']
 263                 m.append(str(value))
 264                 m.append('\n\nMail Gateway Help\n=================')
 265                 m.append(fulldoc)
 266                 m = self.bounce_message(message, sendto, m)
 267             except Unauthorized, value:
 268                 # just inform the user that he is not authorized
 269                 sendto = [sendto[0][1]]
 270                 m = ['']
 271                 m.append(str(value))
 272                 m = self.bounce_message(message, sendto, m)
 273             except:
 274                 # bounce the message back to the sender with the error message
 275                 sendto = [sendto[0][1], self.instance.config.ADMIN_EMAIL]
 276                 m = ['']
 277                 m.append('An unexpected error occurred during the processing')
 278                 m.append('of your message. The tracker administrator is being')
 279                 m.append('notified.\n')
 280                 m.append('----  traceback of failure  ----')
 281                 s = cStringIO.StringIO()
 282                 import traceback
 283                 traceback.print_exc(None, s)
 284                 m.append(s.getvalue())
 285                 m = self.bounce_message(message, sendto, m)
 286         else:
 287             # very bad-looking message - we don't even know who sent it
 288             sendto = [self.instance.config.ADMIN_EMAIL]
 289             m = ['Subject: badly formed message from mail gateway']
 290             m.append('')
 291             m.append('The mail gateway retrieved a message which has no From:')
 292             m.append('line, indicating that it is corrupt. Please check your')
 293             m.append('mail gateway source. Failed message is attached.')
 294             m.append('')
 295             m = self.bounce_message(message, sendto, m,
 296                 subject='Badly formed message from mail gateway')
 297
 298         # now send the message
 299         if SENDMAILDEBUG:
 300             open(SENDMAILDEBUG, 'w').write('From: %s\nTo: %s\n%s\n'%(
 301                 self.instance.config.ADMIN_EMAIL, ', '.join(sendto),
 302                     m.getvalue()))
 303         else:
 304             try:
 305                 smtp = smtplib.SMTP(self.instance.config.MAILHOST)
 306                 smtp.sendmail(self.instance.config.ADMIN_EMAIL, sendto,
 307                     m.getvalue())
 308             except socket.error, value:
 309                 raise MailGWError, "Couldn't send error email: "\
 310                     "mailhost %s"%value
 311             except smtplib.SMTPException, value:
 312                 raise MailGWError, "Couldn't send error email: %s"%value
 313
 314     def bounce_message(self, message, sendto, error,
 315             subject='Failed issue tracker submission'):
 316         ''' create a message that explains the reason for the failed
 317             issue submission to the author and attach the original
 318             message.
 319         '''
 320         msg = cStringIO.StringIO()
 321         writer = MimeWriter.MimeWriter(msg)
 322         writer.addheader('Subject', subject)
 323         writer.addheader('From', '%s <%s>'% (self.instance.config.TRACKER_NAME,
 324             self.instance.config.TRACKER_EMAIL))
 325         writer.addheader('To', ','.join(sendto))
 326         writer.addheader('MIME-Version', '1.0')
 327         part = writer.startmultipartbody('mixed')
 328         part = writer.nextpart()
 329         body = part.startbody('text/plain')
 330         body.write('\n'.join(error))
 331
 332         # attach the original message to the returned message
 333         part = writer.nextpart()
 334         part.addheader('Content-Disposition','attachment')
 335         part.addheader('Content-Description','Message you sent')
 336         body = part.startbody('text/plain')
 337         for header in message.headers:
 338             body.write(header)
 339         body.write('\n')
 340         try:
 341             message.rewindbody()
 342         except IOError, message:
 343             body.write("*** couldn't include message body: %s ***"%message)
 344         else:
 345             body.write(message.fp.read())
 346
 347         writer.lastpart()
 348         return msg
 349
 350     def get_part_data_decoded(self,part):
 351         encoding = part.getencoding()
 352         data = None
 353         if encoding == 'base64':
 354             # BUG: is base64 really used for text encoding or
 355             # are we inserting zip files here.
 356             data = binascii.a2b_base64(part.fp.read())
 357         elif encoding == 'quoted-printable':
 358             # the quopri module wants to work with files
 359             decoded = cStringIO.StringIO()
 360             quopri.decode(part.fp, decoded)
 361             data = decoded.getvalue()
 362         elif encoding == 'uuencoded':
 363             data = binascii.a2b_uu(part.fp.read())
 364         else:
 365             # take it as text
 366             data = part.fp.read()
 367         return data
 368
 369     def handle_message(self, message):
 370         ''' message - a Message instance
 371
 372         Parse the message as per the module docstring.
 373         '''
 374         # handle the subject line
 375         subject = message.getheader('subject', '')
 376
 377         if subject.strip() == 'help':
 378             raise MailUsageHelp
 379
 380         m = subject_re.match(subject)
 381
 382         # check for well-formed subject line
 383         if m:
 384             # get the classname
 385             classname = m.group('classname')
 386             if classname is None:
 387                 # no classname, fallback on the default
 388                 if hasattr(self.instance.config, 'MAIL_DEFAULT_CLASS') and \
 389                         self.instance.config.MAIL_DEFAULT_CLASS:
 390                     classname = self.instance.config.MAIL_DEFAULT_CLASS
 391                 else:
 392                     # fail
 393                     m = None
 394
 395         if not m:
 396             raise MailUsageError, '''
 397 The message you sent to roundup did not contain a properly formed subject
 398 line. The subject must contain a class name or designator to indicate the
 399 "topic" of the message. For example:
 400     Subject: [issue] This is a new issue
 401       - this will create a new issue in the tracker with the title "This is
 402         a new issue".
 403     Subject: [issue1234] This is a followup to issue 1234
 404       - this will append the message's contents to the existing issue 1234
 405         in the tracker.
 406
 407 Subject was: "%s"
 408 '''%subject
 409
 410         # get the class
 411         try:
 412             cl = self.db.getclass(classname)
 413         except KeyError:
 414             raise MailUsageError, '''
 415 The class name you identified in the subject line ("%s") does not exist in the
 416 database.
 417
 418 Valid class names are: %s
 419 Subject was: "%s"
 420 '''%(classname, ', '.join(self.db.getclasses()), subject)
 421
 422         # get the optional nodeid
 423         nodeid = m.group('nodeid')
 424
 425         # title is optional too
 426         title = m.group('title')
 427         if title:
 428             title = title.strip()
 429         else:
 430             title = ''
 431
 432         # strip off the quotes that dumb emailers put around the subject, like
 433         #      Re: "[issue1] bla blah"
 434         if m.group('quote') and title.endswith('"'):
 435             title = title[:-1]
 436
 437         # but we do need either a title or a nodeid...
 438         if nodeid is None and not title:
 439             raise MailUsageError, '''
 440 I cannot match your message to a node in the database - you need to either
 441 supply a full node identifier (with number, eg "[issue123]" or keep the
 442 previous subject title intact so I can match that.
 443
 444 Subject was: "%s"
 445 '''%subject
 446
 447         # If there's no nodeid, check to see if this is a followup and
 448         # maybe someone's responded to the initial mail that created an
 449         # entry. Try to find the matching nodes with the same title, and
 450         # use the _last_ one matched (since that'll _usually_ be the most
 451         # recent...)
 452         if nodeid is None and m.group('refwd'):
 453             l = cl.stringFind(title=title)
 454             if l:
 455                 nodeid = l[-1]
 456
 457         # if a nodeid was specified, make sure it's valid
 458         if nodeid is not None and not cl.hasnode(nodeid):
 459             raise MailUsageError, '''
 460 The node specified by the designator in the subject of your message ("%s")
 461 does not exist.
 462
 463 Subject was: "%s"
 464 '''%(nodeid, subject)
 465
 466         #
 467         # handle the users
 468         #
 469         # Don't create users if anonymous isn't allowed to register
 470         create = 1
 471         anonid = self.db.user.lookup('anonymous')
 472         if not self.db.security.hasPermission('Email Registration', anonid):
 473             create = 0
 474
 475         # ok, now figure out who the author is - create a new user if the
 476         # "create" flag is true
 477         author = uidFromAddress(self.db, message.getaddrlist('from')[0],
 478             create=create)
 479
 480         # if we're not recognised, and we don't get added as a user, then we
 481         # must be anonymous
 482         if not author:
 483             author = anonid
 484
 485         # make sure the author has permission to use the email interface
 486         if not self.db.security.hasPermission('Email Access', author):
 487             if author == anonid:
 488                 # we're anonymous and we need to be a registered user
 489                 raise Unauthorized, '''
 490 You are not a registered user.
 491
 492 Unknown address: %s
 493 '''%message.getaddrlist('from')[0][1]
 494             else:
 495                 # we're registered and we're _still_ not allowed access
 496                 raise Unauthorized, 'You are not permitted to access '\
 497                     'this tracker.'
 498
 499         # make sure they're allowed to edit this class of information
 500         if not self.db.security.hasPermission('Edit', author, classname):
 501             raise Unauthorized, 'You are not permitted to edit %s.'%classname
 502
 503         # the author may have been created - make sure the change is
 504         # committed before we reopen the database
 505         self.db.commit()
 506
 507         # reopen the database as the author
 508         username = self.db.user.get(author, 'username')
 509         self.db.close()
 510         self.db = self.instance.open(username)
 511
 512         # re-get the class with the new database connection
 513         cl = self.db.getclass(classname)
 514
 515         # now update the recipients list
 516         recipients = []
 517         tracker_email = self.instance.config.TRACKER_EMAIL.lower()
 518         for recipient in message.getaddrlist('to') + message.getaddrlist('cc'):
 519             r = recipient[1].strip().lower()
 520             if r == tracker_email or not r:
 521                 continue
 522
 523             # look up the recipient - create if necessary (and we're
 524             # allowed to)
 525             recipient = uidFromAddress(self.db, recipient, create)
 526
 527             # if all's well, add the recipient to the list
 528             if recipient:
 529                 recipients.append(recipient)
 530
 531         #
 532         # extract the args
 533         #
 534         subject_args = m.group('args')
 535
 536         #
 537         # handle the subject argument list
 538         #
 539         # figure what the properties of this Class are
 540         properties = cl.getprops()
 541         props = {}
 542         args = m.group('args')
 543         if args:
 544             errors = []
 545             for prop in string.split(args, ';'):
 546                 # extract the property name and value
 547                 try:
 548                     propname, value = prop.split('=')
 549                 except ValueError, message:
 550                     errors.append('not of form [arg=value,'
 551                         'value,...;arg=value,value...]')
 552                     break
 553
 554                 # ensure it's a valid property name
 555                 propname = propname.strip()
 556                 try:
 557                     proptype =  properties[propname]
 558                 except KeyError:
 559                     errors.append('refers to an invalid property: '
 560                         '"%s"'%propname)
 561                     continue
 562
 563                 # convert the string value to a real property value
 564                 if isinstance(proptype, hyperdb.String):
 565                     props[propname] = value.strip()
 566                 if isinstance(proptype, hyperdb.Password):
 567                     props[propname] = password.Password(value.strip())
 568                 elif isinstance(proptype, hyperdb.Date):
 569                     try:
 570                         props[propname] = date.Date(value.strip())
 571                     except ValueError, message:
 572                         errors.append('contains an invalid date for '
 573                             '%s.'%propname)
 574                 elif isinstance(proptype, hyperdb.Interval):
 575                     try:
 576                         props[propname] = date.Interval(value)
 577                     except ValueError, message:
 578                         errors.append('contains an invalid date interval'
 579                             'for %s.'%propname)
 580                 elif isinstance(proptype, hyperdb.Link):
 581                     linkcl = self.db.classes[proptype.classname]
 582                     propkey = linkcl.labelprop(default_to_id=1)
 583                     try:
 584                         props[propname] = linkcl.lookup(value)
 585                     except KeyError, message:
 586                         errors.append('"%s" is not a value for %s.'%(value,
 587                             propname))
 588                 elif isinstance(proptype, hyperdb.Multilink):
 589                     # get the linked class
 590                     linkcl = self.db.classes[proptype.classname]
 591                     propkey = linkcl.labelprop(default_to_id=1)
 592                     if nodeid:
 593                         curvalue = cl.get(nodeid, propname)
 594                     else:
 595                         curvalue = []
 596
 597                     # handle each add/remove in turn
 598                     # keep an extra list for all items that are
 599                     # definitely in the new list (in case of e.g.
 600                     # <propname>=A,+B, which should replace the old
 601                     # list with A,B)
 602                     set = 0
 603                     newvalue = []
 604                     for item in value.split(','):
 605                         item = item.strip()
 606
 607                         # handle +/-
 608                         remove = 0
 609                         if item.startswith('-'):
 610                             remove = 1
 611                             item = item[1:]
 612                         elif item.startswith('+'):
 613                             item = item[1:]
 614                         else:
 615                             set = 1
 616
 617                         # look up the value
 618                         try:
 619                             item = linkcl.lookup(item)
 620                         except KeyError, message:
 621                             errors.append('"%s" is not a value for %s.'%(item,
 622                                 propname))
 623                             continue
 624
 625                         # perform the add/remove
 626                         if remove:
 627                             try:
 628                                 curvalue.remove(item)
 629                             except ValueError:
 630                                 errors.append('"%s" is not currently in '
 631                                     'for %s.'%(item, propname))
 632                                 continue
 633                         else:
 634                             newvalue.append(item)
 635                             if item not in curvalue:
 636                                 curvalue.append(item)
 637
 638                     # that's it, set the new Multilink property value,
 639                     # or overwrite it completely
 640                     if set:
 641                         props[propname] = newvalue
 642                     else:
 643                         props[propname] = curvalue
 644                 elif isinstance(proptype, hyperdb.Boolean):
 645                     value = value.strip()
 646                     props[propname] = value.lower() in ('yes', 'true', 'on', '1')
 647                 elif isinstance(proptype, hyperdb.Number):
 648                     value = value.strip()
 649                     props[propname] = int(value)
 650
 651             # handle any errors parsing the argument list
 652             if errors:
 653                 errors = '\n- '.join(errors)
 654                 raise MailUsageError, '''
 655 There were problems handling your subject line argument list:
 656 - %s
 657
 658 Subject was: "%s"
 659 '''%(errors, subject)
 660
 661         #
 662         # handle message-id and in-reply-to
 663         #
 664         messageid = message.getheader('message-id')
 665         inreplyto = message.getheader('in-reply-to') or ''
 666         # generate a messageid if there isn't one
 667         if not messageid:
 668             messageid = "<%s.%s.%s%s@%s>"%(time.time(), random.random(),
 669                 classname, nodeid, self.instance.config.MAIL_DOMAIN)
 670
 671         #
 672         # now handle the body - find the message
 673         #
 674         content_type =  message.gettype()
 675         attachments = []
 676         # General multipart handling:
 677         #   Take the first text/plain part, anything else is considered an
 678         #   attachment.
 679         # multipart/mixed: multiple "unrelated" parts.
 680         # multipart/signed (rfc 1847):
 681         #   The control information is carried in the second of the two
 682         #   required body parts.
 683         #   ACTION: Default, so if content is text/plain we get it.
 684         # multipart/encrypted (rfc 1847):
 685         #   The control information is carried in the first of the two
 686         #   required body parts.
 687         #   ACTION: Not handleable as the content is encrypted.
 688         # multipart/related (rfc 1872, 2112, 2387):
 689         #   The Multipart/Related content-type addresses the MIME
 690         #   representation of compound objects.
 691         #   ACTION: Default. If we are lucky there is a text/plain.
 692         #   TODO: One should use the start part and look for an Alternative
 693         #   that is text/plain.
 694         # multipart/Alternative (rfc 1872, 1892):
 695         #   only in "related" ?
 696         # multipart/report (rfc 1892):
 697         #   e.g. mail system delivery status reports.
 698         #   ACTION: Default. Could be ignored or used for Delivery Notification
 699         #   flagging.
 700         # multipart/form-data:
 701         #   For web forms only.
 702         if content_type == 'multipart/mixed':
 703             # skip over the intro to the first boundary
 704             part = message.getPart()
 705             content = None
 706             while 1:
 707                 # get the next part
 708                 part = message.getPart()
 709                 if part is None:
 710                     break
 711                 # parse it
 712                 subtype = part.gettype()
 713                 if subtype == 'text/plain' and not content:
 714                     # The first text/plain part is the message content.
 715                     content = self.get_part_data_decoded(part)
 716                 elif subtype == 'message/rfc822':
 717                     # handle message/rfc822 specially - the name should be
 718                     # the subject of the actual e-mail embedded here
 719                     i = part.fp.tell()
 720                     mailmess = Message(part.fp)
 721                     name = mailmess.getheader('subject')
 722                     part.fp.seek(i)
 723                     attachments.append((name, 'message/rfc822', part.fp.read()))
 724                 else:
 725                     # try name on Content-Type
 726                     name = part.getparam('name')
 727                     # this is just an attachment
 728                     data = self.get_part_data_decoded(part)
 729                     attachments.append((name, part.gettype(), data))
 730             if content is None:
 731                 raise MailUsageError, '''
 732 Roundup requires the submission to be plain text. The message parser could
 733 not find a text/plain part to use.
 734 '''
 735
 736         elif content_type[:10] == 'multipart/':
 737             # skip over the intro to the first boundary
 738             message.getPart()
 739             content = None
 740             while 1:
 741                 # get the next part
 742                 part = message.getPart()
 743                 if part is None:
 744                     break
 745                 # parse it
 746                 if part.gettype() == 'text/plain' and not content:
 747                     content = self.get_part_data_decoded(part)
 748             if content is None:
 749                 raise MailUsageError, '''
 750 Roundup requires the submission to be plain text. The message parser could
 751 not find a text/plain part to use.
 752 '''
 753
 754         elif content_type != 'text/plain':
 755             raise MailUsageError, '''
 756 Roundup requires the submission to be plain text. The message parser could
 757 not find a text/plain part to use.
 758 '''
 759
 760         else:
 761             content = self.get_part_data_decoded(message)
 762
 763         # figure how much we should muck around with the email body
 764         keep_citations = getattr(self.instance, 'EMAIL_KEEP_QUOTED_TEXT',
 765             'no') == 'yes'
 766         keep_body = getattr(self.instance, 'EMAIL_LEAVE_BODY_UNCHANGED',
 767             'no') == 'yes'
 768
 769         # parse the body of the message, stripping out bits as appropriate
 770         summary, content = parseContent(content, keep_citations,
 771             keep_body)
 772
 773         #
 774         # handle the attachments
 775         #
 776         files = []
 777         for (name, mime_type, data) in attachments:
 778             if not name:
 779                 name = "unnamed"
 780             files.append(self.db.file.create(type=mime_type, name=name,
 781                 content=data))
 782
 783         #
 784         # create the message if there's a message body (content)
 785         #
 786         if content:
 787             message_id = self.db.msg.create(author=author,
 788                 recipients=recipients, date=date.Date('.'), summary=summary,
 789                 content=content, files=files, messageid=messageid,
 790                 inreplyto=inreplyto)
 791
 792             # attach the message to the node
 793             if nodeid:
 794                 # add the message to the node's list
 795                 messages = cl.get(nodeid, 'messages')
 796                 messages.append(message_id)
 797                 props['messages'] = messages
 798             else:
 799                 # pre-load the messages list
 800                 props['messages'] = [message_id]
 801
 802                 # set the title to the subject
 803                 if properties.has_key('title') and not props.has_key('title'):
 804                     props['title'] = title
 805
 806         #
 807         # perform the node change / create
 808         #
 809         try:
 810             if nodeid:
 811                 cl.set(nodeid, **props)
 812             else:
 813                 nodeid = cl.create(**props)
 814         except (TypeError, IndexError, ValueError), message:
 815             raise MailUsageError, '''
 816 There was a problem with the message you sent:
 817    %s
 818 '''%message
 819
 820         # commit the changes to the DB
 821         self.db.commit()
 822
 823         return nodeid
 824
 825 def extractUserFromList(userClass, users):
 826     '''Given a list of users, try to extract the first non-anonymous user
 827        and return that user, otherwise return None
 828     '''
 829     if len(users) > 1:
 830         for user in users:
 831             # make sure we don't match the anonymous or admin user
 832             if userClass.get(user, 'username') in ('admin', 'anonymous'):
 833                 continue
 834             # first valid match will do
 835             return user
 836         # well, I guess we have no choice
 837         return user[0]
 838     elif users:
 839         return users[0]
 840     return None
 841
 842 def uidFromAddress(db, address, create=1):
 843     ''' address is from the rfc822 module, and therefore is (name, addr)
 844
 845         user is created if they don't exist in the db already
 846     '''
 847     (realname, address) = address
 848
 849     # try a straight match of the address
 850     user = extractUserFromList(db.user, db.user.stringFind(address=address))
 851     if user is not None: return user
 852
 853     # try the user alternate addresses if possible
 854     props = db.user.getprops()
 855     if props.has_key('alternate_addresses'):
 856         users = db.user.filter(None, {'alternate_addresses': address})
 857         user = extractUserFromList(db.user, users)
 858         if user is not None: return user
 859
 860     # try to match the username to the address (for local
 861     # submissions where the address is empty)
 862     user = extractUserFromList(db.user, db.user.stringFind(username=address))
 863
 864     # couldn't match address or username, so create a new user
 865     if create:
 866         return db.user.create(username=address, address=address,
 867             realname=realname, roles=db.config.NEW_EMAIL_USER_ROLES)
 868     else:
 869         return 0
 870
 871 def parseContent(content, keep_citations, keep_body,
 872         blank_line=re.compile(r'[\r\n]+\s*[\r\n]+'),
 873         eol=re.compile(r'[\r\n]+'),
 874         signature=re.compile(r'^[>|\s]*[-_]+\s*$'),
 875         original_message=re.compile(r'^[>|\s]*-----Original Message-----$')):
 876     ''' The message body is divided into sections by blank lines.
 877         Sections where the second and all subsequent lines begin with a ">"
 878         or "|" character are considered "quoting sections". The first line of
 879         the first non-quoting section becomes the summary of the message.
 880
 881         If keep_citations is true, then we keep the "quoting sections" in the
 882         content.
 883         If keep_body is true, we even keep the signature sections.
 884     '''
 885     # strip off leading carriage-returns / newlines
 886     i = 0
 887     for i in range(len(content)):
 888         if content[i] not in '\r\n':
 889             break
 890     if i > 0:
 891         sections = blank_line.split(content[i:])
 892     else:
 893         sections = blank_line.split(content)
 894
 895     # extract out the summary from the message
 896     summary = ''
 897     l = []
 898     for section in sections:
 899         #section = section.strip()
 900         if not section:
 901             continue
 902         lines = eol.split(section)
 903         if (lines[0] and lines[0][0] in '>|') or (len(lines) > 1 and
 904                 lines[1] and lines[1][0] in '>|'):
 905             # see if there's a response somewhere inside this section (ie.
 906             # no blank line between quoted message and response)
 907             for line in lines[1:]:
 908                 if line and line[0] not in '>|':
 909                     break
 910             else:
 911                 # we keep quoted bits if specified in the config
 912                 if keep_citations:
 913                     l.append(section)
 914                 continue
 915             # keep this section - it has reponse stuff in it
 916             lines = lines[lines.index(line):]
 917             section = '\n'.join(lines)
 918             # and while we're at it, use the first non-quoted bit as
 919             # our summary
 920             summary = section
 921
 922         if not summary:
 923             # if we don't have our summary yet use the first line of this
 924             # section
 925             summary = section
 926         elif signature.match(lines[0]) and 2 <= len(lines) <= 10:
 927             # lose any signature
 928             break
 929         elif original_message.match(lines[0]):
 930             # ditch the stupid Outlook quoting of the entire original message
 931             break
 932
 933         # and add the section to the output
 934         l.append(section)
 935
 936     # figure the summary - find the first sentence-ending punctuation or the
 937     # first whole line, whichever is longest
 938     sentence = re.search(r'^([^!?\.]+[!?\.])', summary)
 939     if sentence:
 940         sentence = sentence.group(1)
 941     else:
 942         sentence = ''
 943     first = eol.split(summary)[0]
 944     summary = max(sentence, first)
 945
 946     # Now reconstitute the message content minus the bits we don't care
 947     # about.
 948     if not keep_body:
 949         content = '\n\n'.join(l)
 950
 951     return summary, content
 952
 953 # vim: set filetype=python ts=4 sw=4 et si