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 __doc__ = '''
  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.90 2002-09-25 05:13:34 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)\s*\W?\s*)*'
 134     r'\s*(\[(?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         self.main(sys.stdin)
 150         return 0
 151
 152     def do_mailbox(self, filename):
 153         ''' Read a series of messages from the specified unix mailbox file and
 154             pass each to the mail handler.
 155         '''
 156         # open the spool file and lock it
 157         import fcntl, FCNTL
 158         f = open(filename, 'r+')
 159         fcntl.flock(f.fileno(), FCNTL.LOCK_EX)
 160
 161         # handle and clear the mailbox
 162         try:
 163             from mailbox import UnixMailbox
 164             mailbox = UnixMailbox(f, factory=Message)
 165             # grab one message
 166             message = mailbox.next()
 167             while message:
 168                 # handle this message
 169                 self.handle_Message(message)
 170                 message = mailbox.next()
 171             # nuke the file contents
 172             os.ftruncate(f.fileno(), 0)
 173         except:
 174             import traceback
 175             traceback.print_exc()
 176             return 1
 177         fcntl.flock(f.fileno(), FCNTL.LOCK_UN)
 178         return 0
 179
 180     def do_pop(self, server, user='', password=''):
 181         '''Read a series of messages from the specified POP server.
 182         '''
 183         import getpass, poplib, socket
 184         try:
 185             if not user:
 186                 user = raw_input(_('User: '))
 187             if not password:
 188                 password = getpass.getpass()
 189         except (KeyboardInterrupt, EOFError):
 190             # Ctrl C or D maybe also Ctrl Z under Windows.
 191             print "\nAborted by user."
 192             return 1
 193
 194         # open a connection to the server and retrieve all messages
 195         try:
 196             server = poplib.POP3(server)
 197         except socket.error, message:
 198             print "POP server error:", message
 199             return 1
 200         server.user(user)
 201         server.pass_(password)
 202         numMessages = len(server.list()[1])
 203         for i in range(1, numMessages+1):
 204             # retr: returns
 205             # [ pop response e.g. '+OK 459 octets',
 206             #   [ array of message lines ],
 207             #   number of octets ]
 208             lines = server.retr(i)[1]
 209             s = cStringIO.StringIO('\n'.join(lines))
 210             s.seek(0)
 211             self.handle_Message(Message(s))
 212             # delete the message
 213             server.dele(i)
 214
 215         # quit the server to commit changes.
 216         server.quit()
 217         return 0
 218
 219     def main(self, fp):
 220         ''' fp - the file from which to read the Message.
 221         '''
 222         return self.handle_Message(Message(fp))
 223
 224     def handle_Message(self, message):
 225         '''Handle an RFC822 Message
 226
 227         Handle the Message object by calling handle_message() and then cope
 228         with any errors raised by handle_message.
 229         This method's job is to make that call and handle any
 230         errors in a sane manner. It should be replaced if you wish to
 231         handle errors in a different manner.
 232         '''
 233         # in some rare cases, a particularly stuffed-up e-mail will make
 234         # its way into here... try to handle it gracefully
 235         sendto = message.getaddrlist('from')
 236         if sendto:
 237             if not self.trapExceptions:
 238                 return self.handle_message(message)
 239             try:
 240                 return self.handle_message(message)
 241             except MailUsageHelp:
 242                 # bounce the message back to the sender with the usage message
 243                 fulldoc = '\n'.join(string.split(__doc__, '\n')[2:])
 244                 sendto = [sendto[0][1]]
 245                 m = ['']
 246                 m.append('\n\nMail Gateway Help\n=================')
 247                 m.append(fulldoc)
 248                 m = self.bounce_message(message, sendto, m,
 249                     subject="Mail Gateway Help")
 250             except MailUsageError, value:
 251                 # bounce the message back to the sender with the usage message
 252                 fulldoc = '\n'.join(string.split(__doc__, '\n')[2:])
 253                 sendto = [sendto[0][1]]
 254                 m = ['']
 255                 m.append(str(value))
 256                 m.append('\n\nMail Gateway Help\n=================')
 257                 m.append(fulldoc)
 258                 m = self.bounce_message(message, sendto, m)
 259             except Unauthorized, value:
 260                 # just inform the user that he is not authorized
 261                 sendto = [sendto[0][1]]
 262                 m = ['']
 263                 m.append(str(value))
 264                 m = self.bounce_message(message, sendto, m)
 265             except:
 266                 # bounce the message back to the sender with the error message
 267                 sendto = [sendto[0][1], self.instance.config.ADMIN_EMAIL]
 268                 m = ['']
 269                 m.append('An unexpected error occurred during the processing')
 270                 m.append('of your message. The tracker administrator is being')
 271                 m.append('notified.\n')
 272                 m.append('----  traceback of failure  ----')
 273                 s = cStringIO.StringIO()
 274                 import traceback
 275                 traceback.print_exc(None, s)
 276                 m.append(s.getvalue())
 277                 m = self.bounce_message(message, sendto, m)
 278         else:
 279             # very bad-looking message - we don't even know who sent it
 280             sendto = [self.instance.config.ADMIN_EMAIL]
 281             m = ['Subject: badly formed message from mail gateway']
 282             m.append('')
 283             m.append('The mail gateway retrieved a message which has no From:')
 284             m.append('line, indicating that it is corrupt. Please check your')
 285             m.append('mail gateway source. Failed message is attached.')
 286             m.append('')
 287             m = self.bounce_message(message, sendto, m,
 288                 subject='Badly formed message from mail gateway')
 289
 290         # now send the message
 291         if SENDMAILDEBUG:
 292             open(SENDMAILDEBUG, 'w').write('From: %s\nTo: %s\n%s\n'%(
 293                 self.instance.config.ADMIN_EMAIL, ', '.join(sendto),
 294                     m.getvalue()))
 295         else:
 296             try:
 297                 smtp = smtplib.SMTP(self.instance.config.MAILHOST)
 298                 smtp.sendmail(self.instance.config.ADMIN_EMAIL, sendto,
 299                     m.getvalue())
 300             except socket.error, value:
 301                 raise MailGWError, "Couldn't send error email: "\
 302                     "mailhost %s"%value
 303             except smtplib.SMTPException, value:
 304                 raise MailGWError, "Couldn't send error email: %s"%value
 305
 306     def bounce_message(self, message, sendto, error,
 307             subject='Failed issue tracker submission'):
 308         ''' create a message that explains the reason for the failed
 309             issue submission to the author and attach the original
 310             message.
 311         '''
 312         msg = cStringIO.StringIO()
 313         writer = MimeWriter.MimeWriter(msg)
 314         writer.addheader('Subject', subject)
 315         writer.addheader('From', '%s <%s>'% (self.instance.config.TRACKER_NAME,
 316             self.instance.config.TRACKER_EMAIL))
 317         writer.addheader('To', ','.join(sendto))
 318         writer.addheader('MIME-Version', '1.0')
 319         part = writer.startmultipartbody('mixed')
 320         part = writer.nextpart()
 321         body = part.startbody('text/plain')
 322         body.write('\n'.join(error))
 323
 324         # reconstruct the original message
 325         m = cStringIO.StringIO()
 326         w = MimeWriter.MimeWriter(m)
 327         # default the content_type, just in case...
 328         content_type = 'text/plain'
 329         # add the headers except the content-type
 330         for header in message.headers:
 331             header_name = header.split(':')[0]
 332             if header_name.lower() == 'content-type':
 333                 content_type = message.getheader(header_name)
 334             elif message.getheader(header_name):
 335                 w.addheader(header_name, message.getheader(header_name))
 336         # now attach the message body
 337         body = w.startbody(content_type)
 338         try:
 339             message.rewindbody()
 340         except IOError:
 341             body.write("*** couldn't include message body: read from pipe ***")
 342         else:
 343             body.write(message.fp.read())
 344
 345         # attach the original message to the returned message
 346         part = writer.nextpart()
 347         part.addheader('Content-Disposition','attachment')
 348         part.addheader('Content-Description','Message you sent')
 349         part.addheader('Content-Transfer-Encoding', '7bit')
 350         body = part.startbody('message/rfc822')
 351         body.write(m.getvalue())
 352
 353         writer.lastpart()
 354         return msg
 355
 356     def get_part_data_decoded(self,part):
 357         encoding = part.getencoding()
 358         data = None
 359         if encoding == 'base64':
 360             # BUG: is base64 really used for text encoding or
 361             # are we inserting zip files here.
 362             data = binascii.a2b_base64(part.fp.read())
 363         elif encoding == 'quoted-printable':
 364             # the quopri module wants to work with files
 365             decoded = cStringIO.StringIO()
 366             quopri.decode(part.fp, decoded)
 367             data = decoded.getvalue()
 368         elif encoding == 'uuencoded':
 369             data = binascii.a2b_uu(part.fp.read())
 370         else:
 371             # take it as text
 372             data = part.fp.read()
 373         return data
 374
 375     def handle_message(self, message):
 376         ''' message - a Message instance
 377
 378         Parse the message as per the module docstring.
 379         '''
 380         # handle the subject line
 381         subject = message.getheader('subject', '')
 382
 383         if subject.strip() == 'help':
 384             raise MailUsageHelp
 385
 386         m = subject_re.match(subject)
 387
 388         # check for well-formed subject line
 389         if m:
 390             # get the classname
 391             classname = m.group('classname')
 392             if classname is None:
 393                 # no classname, fallback on the default
 394                 if hasattr(self.instance.config, 'MAIL_DEFAULT_CLASS') and \
 395                         self.instance.config.MAIL_DEFAULT_CLASS:
 396                     classname = self.instance.config.MAIL_DEFAULT_CLASS
 397                 else:
 398                     # fail
 399                     m = None
 400
 401         if not m:
 402             raise MailUsageError, '''
 403 The message you sent to roundup did not contain a properly formed subject
 404 line. The subject must contain a class name or designator to indicate the
 405 "topic" of the message. For example:
 406     Subject: [issue] This is a new issue
 407       - this will create a new issue in the tracker with the title "This is
 408         a new issue".
 409     Subject: [issue1234] This is a followup to issue 1234
 410       - this will append the message's contents to the existing issue 1234
 411         in the tracker.
 412
 413 Subject was: "%s"
 414 '''%subject
 415
 416         # get the class
 417         try:
 418             cl = self.db.getclass(classname)
 419         except KeyError:
 420             raise MailUsageError, '''
 421 The class name you identified in the subject line ("%s") does not exist in the
 422 database.
 423
 424 Valid class names are: %s
 425 Subject was: "%s"
 426 '''%(classname, ', '.join(self.db.getclasses()), subject)
 427
 428         # get the optional nodeid
 429         nodeid = m.group('nodeid')
 430
 431         # title is optional too
 432         title = m.group('title')
 433         if title:
 434             title = title.strip()
 435         else:
 436             title = ''
 437
 438         # but we do need either a title or a nodeid...
 439         if nodeid is None and not title:
 440             raise MailUsageError, '''
 441 I cannot match your message to a node in the database - you need to either
 442 supply a full node identifier (with number, eg "[issue123]" or keep the
 443 previous subject title intact so I can match that.
 444
 445 Subject was: "%s"
 446 '''%subject
 447
 448         # If there's no nodeid, check to see if this is a followup and
 449         # maybe someone's responded to the initial mail that created an
 450         # entry. Try to find the matching nodes with the same title, and
 451         # use the _last_ one matched (since that'll _usually_ be the most
 452         # recent...)
 453         if nodeid is None and m.group('refwd'):
 454             l = cl.stringFind(title=title)
 455             if l:
 456                 nodeid = l[-1]
 457
 458         # if a nodeid was specified, make sure it's valid
 459         if nodeid is not None and not cl.hasnode(nodeid):
 460             raise MailUsageError, '''
 461 The node specified by the designator in the subject of your message ("%s")
 462 does not exist.
 463
 464 Subject was: "%s"
 465 '''%(nodeid, subject)
 466
 467         #
 468         # handle the users
 469         #
 470         # Don't create users if anonymous isn't allowed to register
 471         create = 1
 472         anonid = self.db.user.lookup('anonymous')
 473         if not self.db.security.hasPermission('Email Registration', anonid):
 474             create = 0
 475
 476         # ok, now figure out who the author is - create a new user if the
 477         # "create" flag is true
 478         author = uidFromAddress(self.db, message.getaddrlist('from')[0],
 479             create=create)
 480
 481         # no author? means we're not author
 482         if not author:
 483             raise Unauthorized, '''
 484 You are not a registered user.
 485
 486 Unknown address: %s
 487 '''%message.getaddrlist('from')[0][1]
 488
 489         # make sure the author has permission to use the email interface
 490         if not self.db.security.hasPermission('Email Access', author):
 491             raise Unauthorized, 'You are not permitted to access this tracker.'
 492
 493         # make sure they're allowed to edit this class of information
 494         if not self.db.security.hasPermission('Edit', author, classname):
 495             raise Unauthorized, 'You are not permitted to edit %s.'%classname
 496
 497         # the author may have been created - make sure the change is
 498         # committed before we reopen the database
 499         self.db.commit()
 500
 501         # reopen the database as the author
 502         username = self.db.user.get(author, 'username')
 503         self.db.close()
 504         self.db = self.instance.open(username)
 505
 506         # re-get the class with the new database connection
 507         cl = self.db.getclass(classname)
 508
 509         # now update the recipients list
 510         recipients = []
 511         tracker_email = self.instance.config.TRACKER_EMAIL.lower()
 512         for recipient in message.getaddrlist('to') + message.getaddrlist('cc'):
 513             r = recipient[1].strip().lower()
 514             if r == tracker_email or not r:
 515                 continue
 516
 517             # look up the recipient - create if necessary (and we're
 518             # allowed to)
 519             recipient = uidFromAddress(self.db, recipient, create)
 520
 521             # if all's well, add the recipient to the list
 522             if recipient:
 523                 recipients.append(recipient)
 524
 525         #
 526         # extract the args
 527         #
 528         subject_args = m.group('args')
 529
 530         #
 531         # handle the subject argument list
 532         #
 533         # figure what the properties of this Class are
 534         properties = cl.getprops()
 535         props = {}
 536         args = m.group('args')
 537         if args:
 538             errors = []
 539             for prop in string.split(args, ';'):
 540                 # extract the property name and value
 541                 try:
 542                     propname, value = prop.split('=')
 543                 except ValueError, message:
 544                     errors.append('not of form [arg=value,'
 545                         'value,...;arg=value,value...]')
 546                     break
 547
 548                 # ensure it's a valid property name
 549                 propname = propname.strip()
 550                 try:
 551                     proptype =  properties[propname]
 552                 except KeyError:
 553                     errors.append('refers to an invalid property: '
 554                         '"%s"'%propname)
 555                     continue
 556
 557                 # convert the string value to a real property value
 558                 if isinstance(proptype, hyperdb.String):
 559                     props[propname] = value.strip()
 560                 if isinstance(proptype, hyperdb.Password):
 561                     props[propname] = password.Password(value.strip())
 562                 elif isinstance(proptype, hyperdb.Date):
 563                     try:
 564                         props[propname] = date.Date(value.strip())
 565                     except ValueError, message:
 566                         errors.append('contains an invalid date for '
 567                             '%s.'%propname)
 568                 elif isinstance(proptype, hyperdb.Interval):
 569                     try:
 570                         props[propname] = date.Interval(value)
 571                     except ValueError, message:
 572                         errors.append('contains an invalid date interval'
 573                             'for %s.'%propname)
 574                 elif isinstance(proptype, hyperdb.Link):
 575                     linkcl = self.db.classes[proptype.classname]
 576                     propkey = linkcl.labelprop(default_to_id=1)
 577                     try:
 578                         props[propname] = linkcl.lookup(value)
 579                     except KeyError, message:
 580                         errors.append('"%s" is not a value for %s.'%(value,
 581                             propname))
 582                 elif isinstance(proptype, hyperdb.Multilink):
 583                     # get the linked class
 584                     linkcl = self.db.classes[proptype.classname]
 585                     propkey = linkcl.labelprop(default_to_id=1)
 586                     if nodeid:
 587                         curvalue = cl.get(nodeid, propname)
 588                     else:
 589                         curvalue = []
 590
 591                     # handle each add/remove in turn
 592                     # keep an extra list for all items that are
 593                     # definitely in the new list (in case of e.g.
 594                     # <propname>=A,+B, which should replace the old
 595                     # list with A,B)
 596                     set = 0
 597                     newvalue = []
 598                     for item in value.split(','):
 599                         item = item.strip()
 600
 601                         # handle +/-
 602                         remove = 0
 603                         if item.startswith('-'):
 604                             remove = 1
 605                             item = item[1:]
 606                         elif item.startswith('+'):
 607                             item = item[1:]
 608                         else:
 609                             set = 1
 610
 611                         # look up the value
 612                         try:
 613                             item = linkcl.lookup(item)
 614                         except KeyError, message:
 615                             errors.append('"%s" is not a value for %s.'%(item,
 616                                 propname))
 617                             continue
 618
 619                         # perform the add/remove
 620                         if remove:
 621                             try:
 622                                 curvalue.remove(item)
 623                             except ValueError:
 624                                 errors.append('"%s" is not currently in '
 625                                     'for %s.'%(item, propname))
 626                                 continue
 627                         else:
 628                             newvalue.append(item)
 629                             if item not in curvalue:
 630                                 curvalue.append(item)
 631
 632                     # that's it, set the new Multilink property value,
 633                     # or overwrite it completely
 634                     if set:
 635                         props[propname] = newvalue
 636                     else:
 637                         props[propname] = curvalue
 638                 elif isinstance(proptype, hyperdb.Boolean):
 639                     value = value.strip()
 640                     props[propname] = value.lower() in ('yes', 'true', 'on', '1')
 641                 elif isinstance(proptype, hyperdb.Number):
 642                     value = value.strip()
 643                     props[propname] = int(value)
 644
 645             # handle any errors parsing the argument list
 646             if errors:
 647                 errors = '\n- '.join(errors)
 648                 raise MailUsageError, '''
 649 There were problems handling your subject line argument list:
 650 - %s
 651
 652 Subject was: "%s"
 653 '''%(errors, subject)
 654
 655         #
 656         # handle message-id and in-reply-to
 657         #
 658         messageid = message.getheader('message-id')
 659         inreplyto = message.getheader('in-reply-to') or ''
 660         # generate a messageid if there isn't one
 661         if not messageid:
 662             messageid = "<%s.%s.%s%s@%s>"%(time.time(), random.random(),
 663                 classname, nodeid, self.instance.config.MAIL_DOMAIN)
 664
 665         #
 666         # now handle the body - find the message
 667         #
 668         content_type =  message.gettype()
 669         attachments = []
 670         # General multipart handling:
 671         #   Take the first text/plain part, anything else is considered an
 672         #   attachment.
 673         # multipart/mixed: multiple "unrelated" parts.
 674         # multipart/signed (rfc 1847):
 675         #   The control information is carried in the second of the two
 676         #   required body parts.
 677         #   ACTION: Default, so if content is text/plain we get it.
 678         # multipart/encrypted (rfc 1847):
 679         #   The control information is carried in the first of the two
 680         #   required body parts.
 681         #   ACTION: Not handleable as the content is encrypted.
 682         # multipart/related (rfc 1872, 2112, 2387):
 683         #   The Multipart/Related content-type addresses the MIME
 684         #   representation of compound objects.
 685         #   ACTION: Default. If we are lucky there is a text/plain.
 686         #   TODO: One should use the start part and look for an Alternative
 687         #   that is text/plain.
 688         # multipart/Alternative (rfc 1872, 1892):
 689         #   only in "related" ?
 690         # multipart/report (rfc 1892):
 691         #   e.g. mail system delivery status reports.
 692         #   ACTION: Default. Could be ignored or used for Delivery Notification
 693         #   flagging.
 694         # multipart/form-data:
 695         #   For web forms only.
 696         if content_type == 'multipart/mixed':
 697             # skip over the intro to the first boundary
 698             part = message.getPart()
 699             content = None
 700             while 1:
 701                 # get the next part
 702                 part = message.getPart()
 703                 if part is None:
 704                     break
 705                 # parse it
 706                 subtype = part.gettype()
 707                 if subtype == 'text/plain' and not content:
 708                     # The first text/plain part is the message content.
 709                     content = self.get_part_data_decoded(part)
 710                 elif subtype == 'message/rfc822':
 711                     # handle message/rfc822 specially - the name should be
 712                     # the subject of the actual e-mail embedded here
 713                     i = part.fp.tell()
 714                     mailmess = Message(part.fp)
 715                     name = mailmess.getheader('subject')
 716                     part.fp.seek(i)
 717                     attachments.append((name, 'message/rfc822', part.fp.read()))
 718                 else:
 719                     # try name on Content-Type
 720                     name = part.getparam('name')
 721                     # this is just an attachment
 722                     data = self.get_part_data_decoded(part)
 723                     attachments.append((name, part.gettype(), data))
 724             if content is None:
 725                 raise MailUsageError, '''
 726 Roundup requires the submission to be plain text. The message parser could
 727 not find a text/plain part to use.
 728 '''
 729
 730         elif content_type[:10] == 'multipart/':
 731             # skip over the intro to the first boundary
 732             message.getPart()
 733             content = None
 734             while 1:
 735                 # get the next part
 736                 part = message.getPart()
 737                 if part is None:
 738                     break
 739                 # parse it
 740                 if part.gettype() == 'text/plain' and not content:
 741                     content = self.get_part_data_decoded(part)
 742             if content is None:
 743                 raise MailUsageError, '''
 744 Roundup requires the submission to be plain text. The message parser could
 745 not find a text/plain part to use.
 746 '''
 747
 748         elif content_type != 'text/plain':
 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         else:
 755             content = self.get_part_data_decoded(message)
 756
 757         # figure how much we should muck around with the email body
 758         keep_citations = getattr(self.instance, 'EMAIL_KEEP_QUOTED_TEXT',
 759             'no') == 'yes'
 760         keep_body = getattr(self.instance, 'EMAIL_LEAVE_BODY_UNCHANGED',
 761             'no') == 'yes'
 762
 763         # parse the body of the message, stripping out bits as appropriate
 764         summary, content = parseContent(content, keep_citations,
 765             keep_body)
 766
 767         #
 768         # handle the attachments
 769         #
 770         files = []
 771         for (name, mime_type, data) in attachments:
 772             if not name:
 773                 name = "unnamed"
 774             files.append(self.db.file.create(type=mime_type, name=name,
 775                 content=data))
 776
 777         #
 778         # create the message if there's a message body (content)
 779         #
 780         if content:
 781             message_id = self.db.msg.create(author=author,
 782                 recipients=recipients, date=date.Date('.'), summary=summary,
 783                 content=content, files=files, messageid=messageid,
 784                 inreplyto=inreplyto)
 785
 786             # attach the message to the node
 787             if nodeid:
 788                 # add the message to the node's list
 789                 messages = cl.get(nodeid, 'messages')
 790                 messages.append(message_id)
 791                 props['messages'] = messages
 792             else:
 793                 # pre-load the messages list
 794                 props['messages'] = [message_id]
 795
 796                 # set the title to the subject
 797                 if properties.has_key('title') and not props.has_key('title'):
 798                     props['title'] = title
 799
 800         #
 801         # perform the node change / create
 802         #
 803         try:
 804             if nodeid:
 805                 cl.set(nodeid, **props)
 806             else:
 807                 nodeid = cl.create(**props)
 808         except (TypeError, IndexError, ValueError), message:
 809             raise MailUsageError, '''
 810 There was a problem with the message you sent:
 811    %s
 812 '''%message
 813
 814         # commit the changes to the DB
 815         self.db.commit()
 816
 817         return nodeid
 818
 819 def extractUserFromList(userClass, users):
 820     '''Given a list of users, try to extract the first non-anonymous user
 821        and return that user, otherwise return None
 822     '''
 823     if len(users) > 1:
 824         for user in users:
 825             # make sure we don't match the anonymous or admin user
 826             if userClass.get(user, 'username') in ('admin', 'anonymous'):
 827                 continue
 828             # first valid match will do
 829             return user
 830         # well, I guess we have no choice
 831         return user[0]
 832     elif users:
 833         return users[0]
 834     return None
 835
 836 def uidFromAddress(db, address, create=1):
 837     ''' address is from the rfc822 module, and therefore is (name, addr)
 838
 839         user is created if they don't exist in the db already
 840     '''
 841     (realname, address) = address
 842
 843     # try a straight match of the address
 844     user = extractUserFromList(db.user, db.user.stringFind(address=address))
 845     if user is not None: return user
 846
 847     # try the user alternate addresses if possible
 848     props = db.user.getprops()
 849     if props.has_key('alternate_addresses'):
 850         users = db.user.filter(None, {'alternate_addresses': address},
 851             [], [])
 852         user = extractUserFromList(db.user, users)
 853         if user is not None: return user
 854
 855     # try to match the username to the address (for local
 856     # submissions where the address is empty)
 857     user = extractUserFromList(db.user, db.user.stringFind(username=address))
 858
 859     # couldn't match address or username, so create a new user
 860     if create:
 861         return db.user.create(username=address, address=address,
 862             realname=realname, roles=db.config.NEW_EMAIL_USER_ROLES)
 863     else:
 864         return 0
 865
 866 def parseContent(content, keep_citations, keep_body,
 867         blank_line=re.compile(r'[\r\n]+\s*[\r\n]+'),
 868         eol=re.compile(r'[\r\n]+'),
 869         signature=re.compile(r'^[>|\s]*[-_]+\s*$'),
 870         original_message=re.compile(r'^[>|\s]*-----Original Message-----$')):
 871     ''' The message body is divided into sections by blank lines.
 872         Sections where the second and all subsequent lines begin with a ">"
 873         or "|" character are considered "quoting sections". The first line of
 874         the first non-quoting section becomes the summary of the message.
 875
 876         If keep_citations is true, then we keep the "quoting sections" in the
 877         content.
 878         If keep_body is true, we even keep the signature sections.
 879     '''
 880     # strip off leading carriage-returns / newlines
 881     i = 0
 882     for i in range(len(content)):
 883         if content[i] not in '\r\n':
 884             break
 885     if i > 0:
 886         sections = blank_line.split(content[i:])
 887     else:
 888         sections = blank_line.split(content)
 889
 890     # extract out the summary from the message
 891     summary = ''
 892     l = []
 893     for section in sections:
 894         #section = section.strip()
 895         if not section:
 896             continue
 897         lines = eol.split(section)
 898         if (lines[0] and lines[0][0] in '>|') or (len(lines) > 1 and
 899                 lines[1] and lines[1][0] in '>|'):
 900             # see if there's a response somewhere inside this section (ie.
 901             # no blank line between quoted message and response)
 902             for line in lines[1:]:
 903                 if line and line[0] not in '>|':
 904                     break
 905             else:
 906                 # we keep quoted bits if specified in the config
 907                 if keep_citations:
 908                     l.append(section)
 909                 continue
 910             # keep this section - it has reponse stuff in it
 911             if not summary:
 912                 # and while we're at it, use the first non-quoted bit as
 913                 # our summary
 914                 summary = line
 915             lines = lines[lines.index(line):]
 916             section = '\n'.join(lines)
 917
 918         if not summary:
 919             # if we don't have our summary yet use the first line of this
 920             # section
 921             summary = lines[0]
 922         elif signature.match(lines[0]) and 2 <= len(lines) <= 10:
 923             # lose any signature
 924             break
 925         elif original_message.match(lines[0]):
 926             # ditch the stupid Outlook quoting of the entire original message
 927             break
 928
 929         # and add the section to the output
 930         l.append(section)
 931
 932     # Now reconstitute the message content minus the bits we don't care
 933     # about.
 934     if not keep_body:
 935         content = '\n\n'.join(l)
 936
 937     return summary, content
 938
 939 # vim: set filetype=python ts=4 sw=4 et si