"""

Start at the Eudora specific pattern "^From ???@???" and keep gathering

all headers. When an empty line is found, emit the headers.

Replace ???@??? with the e-mail address in "From: " (if found), or else

use "Sender: " or else "Return-Path: " or else use the magic address

"unknown@unknown.unknown" for later analysis (easily greppable).

Also add a "Date: " if missing (mostly for outbound mail sent by

yourself) which is extracted from the Eudora "From ???@??? ..." line,

but is reformatted, because Eudora has the order in the datum items

wrong.

Eudora uses:

dayname-abbr monthname-abbr monthnumber-nn time-hh:mm:ss

year-yyyy

whereas it should be:

dayname-abbr monthnumber-nn monthname-abbr year-yyyy

time-hh:mm:ss

Example:

Thu 03 Jan 2002 11:42:42 (24 characters)

"""

global attachments_listed, attachments_found, attachments_missing, attachments_dirs

global paths_found, paths_missing, message_count

global re_initial_whitespace

global toc_info, replies, target

global edir

attachments_listed = 0

attachments_found = 0

attachments_missing = 0

edir = embedded_dir

print "Converting %s" % (mbx,)

if not mbx:

EudoraLog.fatal( P + ': usage: Eudora2Mbox.py eudora-mailbox-file.mbx' )

return 0

attachments_dirs = []

target = ''

format = None

if opts:

for f, v in opts:

if f == '-a':

attachments_dirs = v.split(':')

elif f == '-f':

format = v.strip().lower()

elif f == '-t':

target = v

EudoraLog.log = EudoraLog.Log( mbx )

try:

INPUT = open( mbx, 'r' )

except IOError, ( errno, strerror ):

INPUT = None

return EudoraLog.fatal( P + ': cannot open "' + mbx + '", ' + strerror )

newfile = mbx + '.new'

newmailbox = create_mailbox( newfile, format )

toc_info = TOC_Info( mbx )

replies = Replies( INPUT )

headers = None

last_file_position = 0

msg_offset = 0

msg_lines = []

attachments = []

embeddeds = []

message = None

EudoraLog.msg_no = 0 # number of messages in this mailbox

EudoraLog.line_no = 0 # line number of current line record (for messages)

# Main loop, that reads the mailbox file and converts.

#

# Sad issues with the nice python construct

# for line in INPUT:

# It appears to read the whole file into an array before executing

# the loop! Besides being grotesquely inefficient, it blows up the

# use of tell() within the loop. See

# <http://www.python.org/peps/pep-0234.html>

while True:

line = INPUT.readline()

if msg_lines and (not line or re_message_start.match( line )):

(headers, body, attachments, embeddeds, mbx, is_html) = extract_pieces(msg_lines, last_file_position, mbx)

message = craft_message(headers, body, attachments, embeddeds, mbx, is_html)

try:

message_count = message_count + 1

newmailbox.add(message)

except TypeError:

print str(headers)

print message.get_content_type()

traceback.print_exc(file=sys.stdout)

EudoraLog.msg_no = EudoraLog.msg_no + 1

msg_offset = last_file_position

msg_lines = []

if not line:

break

msg_lines.append(strip_linesep(line) + "\n")

last_file_position = INPUT.tell()

EudoraLog.line_no += 1

# Check if the file isn't empty and any messages have been processed.

if EudoraLog.line_no == 0:

EudoraLog.log.warn( 'empty file' )

elif EudoraLog.msg_no == 0:

EudoraLog.log.error( 'no messages (not a Eudora mailbox file?)' )

if True:

print

print "\nMissing path count:"

for (path, count) in paths_missing.iteritems():

print "%s: %d" % (path, count)

print "\nFound path count:"

for (path, count) in paths_found.iteritems():

print "%s: %d" % (path, count)

print "\n------------------------------"

print "Attachments Listed: %d\nAttachments Found: %d\nAttachments Missing:%d" % (attachments_listed, attachments_found, attachments_missing)

print "------------------------------"

if EudoraLog.msg_no == 0: msg_str = 'total: Converted no messages'

if EudoraLog.msg_no == 1: msg_str = 'total: Converted 1 message'

if EudoraLog.msg_no >= 1: msg_str = 'total: Converted %d messages' % (EudoraLog.msg_no,)

print msg_str

if EudoraLog.verbose >= 0:

print EudoraLog.log.summary()

# Finish up. Close failures usually indicate filesystem full.

if newmailbox:

newmailbox.close()

if INPUT:

try:

INPUT.close()

except IOError:

return EudoraLog.fatal( P + ': cannot close "' + mbx + '"' )

"""Creates and returns a Python mailbox object that can be

used to write mail messages into.

If format is not None, it can be one of mbox, maildir, mmdf,

mh, babyl, to control the type of mailbox created.

"""

try:

if not format or format=='mbox':

newmailbox = mbox( mailbox_name )

elif format=='maildir':

newmailbox = Maildir( mailbox_name )

elif format=='mmdf':

newmailbox = MMDF( mailbox_name )

elif format=='mh':

newmailbox = MH( mailbox_name )

elif format=='babyl':

newmailbox = Babyl( mailbox_name )

except IOError, ( errno, strerror ):

newmailbox = None

return EudoraLog.fatal( P + ': cannot open "' + mailbox_name + '", ' + strerror )

"""Takes four parameters. The first is a list of line strings

containing the headers and body of a message from a Eudora MBX

file. The second is the offset of the first character in the

first line in the msg_lines list within the MBX file we're

processing. The third is the name of the MBX file we're

reading. The fourth, inner_mesg, is a boolean controlling

whether or not the pieces were are extracting are a top-level

message in the MBX file. If inner_mesg is true, we will carry

out our processing under the assumption that we are handling

an attached message carried in an message/rfc822 segment.

Returns a tuple (header, body, attachments, embeddeds, mbx)

containing a Header object, a body String containing the body

of the message, a list of attachment definition tuples, a list

of embedded definition tuples, and the name of the MBX file

we're processing."""

global toc_info, replies

global target

headers = Header()

body = []

attachments = []

embeddeds = []

in_headers = True

found_rfc822_inner_mesg = False

is_html = False

if not inner_mesg:

headers.add( 'From ', msg_lines[0][5:].strip() )

for line in msg_lines:

if in_headers:

if re_initial_whitespace.match( line ):

# Header "folding" (RFC 2822 3.2.3)

headers.appendToLast( line )

elif len( line.strip() ) != 0:

# Message header

headers.add_line(line)

attachment_matcher = re_x_attachment.match( line )

if attachment_matcher:

files = attachment_matcher.group(1)

attach_list = re.split(';\s*', files)

for attachment in attach_list:

attachments.append( (attachment, target) )

else:

# End of message headers.

# scrub the header lines we've scanned

if not inner_mesg:

headers.clean(toc_info, msg_offset, replies)

in_headers = False

content_type = headers.getValue('Content-Type:')

if content_type and content_type.lower() == 'message/rfc822':

found_rfc822_inner_mesg = True

print "+",

elif found_rfc822_inner_mesg:

# We're processing a message/rfc822 message,

# and so we don't want to process attachments

# at this level. Instead, we want to properly

# extract all body lines for later processing

body.append(strip_linesep(line) + "\n")

else:

# We're in the body of the text and we need to

# handle attachments

if not is_html and re_xhtml.search( line ) or re_normal_html.search( line ):

is_html = True

if attachments_dirs and re_attachment.search( line ):

# remove the newline that

# Eudora inserts before the

# 'Attachment Converted' line.

if len(body) > 0 and (body[-1] == '\n' or body[-1] == '\r\n'):

body.pop()

#EudoraLog.log.warn("Adding attachment with contenttype = " + contenttype)

attachments.append( (line, target) )

else:

embedded_matcher = re_embedded.match ( line )

if embedded_matcher:

filename = embedded_matcher.group(1)

embeddeds.append( filename )

else:

orig_line = line

if scrub_xflowed:

line = re.sub(re_xflowed, '', line)

line = re.sub(re_xhtml, '', line)

line = re.sub(re_pete_stuff, '', line)

if orig_line == line or line != '':

body.append(strip_linesep(line) + "\n")

"""This function handles the creation of a Python

email.message object from the headers and body lists created

during the main loop."""

global edir

attachments_ok = False

embeddedcids = []

if body:

msg_text = ''.join(body)

else:

msg_text = ''

# there's no point honoring 'multipart' if we don't have any

# attachments or embeddeds to attach, so we'll pay most

# attention to whether we have any attachments or embeddeds

# defined for this message

if attachments or embeddeds:

is_multipart = True

else:

is_multipart = False

message = None

contenttype = headers.getValue('Content-Type:')

if contenttype and re_html.search(contenttype):

is_html = True

if not contenttype:

msattach = headers.getValue('X-MS-Attachment:')

if msattach:

message = MIMEMultipart()

attachments_ok = "Dunno"

attachments_contenttype = "Still Dunno"

else:

if is_html:

message = MIMENonMultipart('text', 'html')

else:

message = MIMENonMultipart('text', 'plain')

attachments_ok = False

attachments_contenttype = False

print "T",

elif re_rfc822.search( contenttype ):

print "[",

message = MIMEMessage(craft_message(*extract_pieces(body, -1, mbx, True)))

print "]",

elif not is_multipart:

mimetype = re_single_contenttype.search( contenttype )

if mimetype:

main = mimetype.group(1)

sub = mimetype.group(2)

if main != 'multipart':

message = MIMENonMultipart(main, sub)

attachments_ok = False

attachments_contenttype = False

print "X",

else:

# I've seen some messages in Eudora

# mailboxes that label themselves as

# multitype/related without having any

# attachments ever declared in the

# Eudora box.

#

# By passing here, we allow the next

# clause to go ahead and create an

# appropriate MIMENonMultipart

pass

if not message:

if is_html:

message = MIMENonMultipart('text', 'html')

else:

message = MIMENonMultipart('text', 'plain')

attachments_ok = False

attachments_contenttype = False

else:

subtype = re_multi_contenttype.search( contenttype )

if subtype:

message = MIMEMultipart(_subtype=subtype.group(1))

attachments_ok = subtype.group(1)

attachments_contenttype = contenttype

print "Y",

else:

message = MIMEMultipart()

print "Z",

attachments_ok = "Dunno"

attachments_contenttype = "Still Dunno"

# Need to add support here for processing embeddeds

if embeddeds:

if not isinstance( message, MIMEMultipart):

print "\n\n==================================================\n"

print "Found surprise multipart for embeddeds!\n"

message = MIMEMultipart(_subtype='related')

else:

print "\n\n==================================================\n"

print "Found embeddeds in multipart!\n"

p = EudoraHTMLParser()

try:

p.feed(msg_text)

cids = p.get_cids()

except HTMLParseError:

# okay, we've got unparseable HTML here.

# Let's just use a quick regexp to see if we can make sense of this.

cids = []

for match in re_cids_finder.finditer(msg_text):

cids.append("cid:" + match.group(1))

if not len(cids) == len(embeddeds):

print "cids / embeddeds mismatch!"

print

print mbx

for piece in ['To:', 'From:' , 'Subject:', 'Date:']:

if headers.getValue(piece):

print piece + " " + headers.getValue(piece)[:80]

print

print "\tcid\t\t\t\t\t\t\tembedded"

i = 0

while i < len(cids) or i < len(embeddeds):

if i < len(cids):

print "%d.\t%s" % (i, cids[i]),

print "\t" * (6 - (len(cids[i]) // 8)),

else:

print "%d.\t" % (i, ),

print "\t\t\t\t\t\t",

if i < len(embeddeds):

print embeddeds[i],

if edir and os.path.exists(edir + os.sep + embeddeds[i]):

print " *"

else:

print " !"

else:

print

i = i + 1

cidi = 0

embeddedi = 0

cidsmatched = set()

while cidi < len(cids) or embeddedi < len(embeddeds):

if cidi < len(cids) and embeddedi < len(embeddeds):

if cids[cidi].startswith('cid:'):

actualcid = cids[cidi][4:]

else:

actualcid = cids[cidi]

# the document might have several img

# references to the same cid.. we

# don't want to try to mate up

# multiple inline files in that case

if actualcid in cidsmatched:

cidi = cidi + 1

else:

cidsmatched.add(actualcid)

embeddedcids.append( (actualcid, embeddeds[embeddedi]) )

embeddedi = embeddedi + 1

cidi = cidi + 1

elif embeddedi < len(embeddeds):

embeddedcids.append( (None, embeddeds[embeddedi]) )

embeddedi = embeddedi + 1

else:

# we have more cids than

# embeddeds, keep looping

# through

cidi = cidi + 1

print "\n\nAttaching inline components:"

for c, f in embeddedcids:

print "%s\t%s" % (c, f)

print "\n==================================================\n"

if attachments:

if not isinstance( message, MIMEMultipart):

#print "\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"

#print "Forcing surprise multipart!\n"

#print "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"

message = MIMEMultipart()

# bind the headers into our message

set_headers( message, headers )

try:

# rfc822 MIMEMessage objects handle payload management

# on constructions, we must not try to do it here.

if not isinstance( message, MIMEMessage ):

if not isinstance( message, MIMEMultipart):

message.set_payload(msg_text)

elif is_html:

message.attach(MIMEText(msg_text, _subtype='html'))

else:

message.attach(MIMEText(msg_text))

except Exception, e:

print "\nHEY HEY HEY message = " + str(msg_text) + "\n"

print "Type of message's payload is " + str(type(message.get_payload())) + "\n"

if isinstance( message.get_payload(), list ):

print "Size of message's payload list is " + str(len(message.get_payload())) + "\n"

print ")))))))))))))))))))) First part"

print str(message.get_payload()[0])

print ">>>>>>>>>>>>>>>>>>>> Second part"

print str(message.get_payload()[1])

print "attachments_contenttype is (%s)" % (attachments_contenttype, )

print "attachments_ok is (%s)" % (attachments_ok, )

if attachments:

print "Yeah, attachments were found: %d" % (len(attachments), )

print "EXCEPTION " + str(e) + "\n"

traceback.print_exc(file=sys.stdout)

if attachments:

for aline, atarget in attachments:

handle_attachment( aline, atarget, message )

if embeddedcids:

for cid, filename in embeddedcids:

handle_embedded(cid, filename, message)

for header, value in headers:

if header != 'From ' and not re_contenttype.match( header ):

newheader = header[:-1]

message[newheader] = value

myfrom = headers.getValue('From ')

if myfrom:

"""

Mac versions put "Attachment converted", Windows (Lite) has

"Attachment Converted".

Next comes a system-dependent path to the attachment binary.

On mac version, separated by colons, starts with volume, but omits

path elements between:

Eudora Folder:Attachments Folder.

Windows versions have a full DOS path name to the binary

(Lite version uses 8-char filenames)

This replaces that filepath with a file URI to the file in the

attachments_dirs directories. This has no direct effect in Kmail, but

sometimes Pine can open the file (so long as there aren't any

spaces in the filepath). At least it makes more sense than

leaving the old filepath.

"""

global attachments_listed, attachments_found, attachments_missing, attachments_dirs

global paths_found, paths_missing

global missing_attachments, found_attachments

global mac_mismatches

attachments_listed = attachments_listed + 1

# Mac 1.3.1 has e.g. (Type: 'PDF ' Creator: 'CARO')

# Mac 3.1 has e.g (PDF /CARO) (00000645)

if re_quoted_attachment.match(line):

attachment_desc = re_quoted_attachment.sub( '\\1', line )

elif re_attachment.match(line):

attachment_desc = re_attachment.sub( '\\1', line )

else:

# If we're dealing with attachments recorded by the

# X-Attachments header, line will be a single, naked

# attachment desc, with no Attachment Converted

# surroundings

attachment_desc = line

if attachment_desc.find('"') != -1:

print "**>>**", attachment_desc

attachment_desc = strip_linesep(attachment_desc)

# some of John's attachment names have an odd OutboundG4:

# prefix which is not present in the filenames on disk..

if attachment_desc.find('OutboundG4:') != -1:

attachment_desc = attachment_desc.replace('OutboundG4:', '')

name = ''

# if has :\, must be windows

etc = ''

if re_dos_path_beginning.match( attachment_desc ):

desc_list = attachment_desc.split( "\\" ) # DOS backslashes

name = desc_list.pop().strip() # pop off last portion of name

orig_path = "/".join(desc_list)

if name[-1] == '"':

name = name[:-1]

elif re_mac_info.match( line ):

name = re_mac_info.sub( '\\1', line )

etc = re_mac_info.sub( '\\2', line ).strip()

dlist = name.split( ":" ) # Mac path delim

name = dlist.pop().strip() # pop off last portion of name

orig_path = "/".join(dlist)

else:

# EudoraLog.log.warn( "FAILED to convert attachment: \'"

# + attachment_desc + "\'" )

name = attachment_desc

orig_path = attachment_desc

if len( name ) <= 0:

return

filename = None

for adir in attachments_dirs:

if not filename or not os.path.exists(filename):

filename = os.path.join( target, adir, name )

if not os.path.isabs( target ):

filename = os.path.join( os.environ['HOME'], filename )

# Trim NULL bytes from filenames (found in old Eudora 2.x mailboxes)

filename = filename.replace(b'\x00', '')

if not os.path.exists(filename):

if name.startswith('OutboundG4:'):

name = name[11:]

print "**** Hey, name is now %s" % (name, )

filename = os.path.join(target, attachments_dir, name)

# our user has attachments that have / characters in

# the file name, but when they got copied over to

# unix, the / chars were taken out, if it would help.

if not os.path.exists(filename):

if name.find('/') != -1:

name=name.replace('/','')

filename = os.path.join(target, adir, name)

# our user also has attachments that have _ characters

# in the file name where the file on disk has spaces.

# translate that as well, if it would help.

if not os.path.exists(filename):

if name.find('_') != -1:

name = name.replace('_', ' ')

filename = os.path.join(target, adir, name)

# our user actually also has attachments that have

# space characters in the file name where the file on

# disk has underscores. if we didn't find the match

# after our last transform, try the rever

if not os.path.exists(filename):

if name.find(' ') != -1:

name = name.replace(' ', '_')

filename = os.path.join(target, adir, name)

# in our user's attachments, we have some files named

# akin to 'filename.ppt 1' and so forth. we're going

# to trim anything after the first whitespace

# character after the first . in the filename

cleaner_match = re_filename_cleaner.match( filename )

if cleaner_match:

filename = cleaner_match.group(1)

# Trim any NULL bytes we might have pulled in

filename = filename.replace(b'\x00', '')

mimeinfo = mimetypes.guess_type(filename)

if not os.path.exists(filename):

cleaner_match = re_filename_cleaner.match(filename.replace('_', ' '))

if cleaner_match and os.path.exists(cleaner_match.group(1)):

filename = cleaner_match.group(1)

if not mimeinfo[0]:

(mimetype, mimesubtype) = ('application', 'octet-stream')

else:

(mimetype, mimesubtype) = mimeinfo[0].split('/')

if os.path.isfile(filename):

fp = open(filename, 'rb')

try:

if mimetype == 'application' or mimetype == 'video':

msg = MIMEApplication(fp.read(), _subtype=mimesubtype)

elif mimetype == 'image':

msg = MIMEImage(fp.read(), _subtype=mimesubtype)

elif mimetype == 'text':

msg = MIMEText(fp.read(), _subtype=mimesubtype)

elif mimetype == 'audio':

msg = MIMEAudio(fp.read(), _subtype=mimesubtype)

else:

EudoraLog.log.error("Unrecognized mime type '%s' while processing attachment '%s'" % (mimeinfo[0], filename))

return

finally:

fp.close()

msg.add_header('Content-Disposition', 'attachment', filename=name)

message.attach(msg)

attachments_found = attachments_found + 1

# EudoraLog.log.warn(" SUCCEEDED finding attachment: \'" + attachment_desc + "\', name = \'" + name + "\'")

if orig_path in paths_found:

paths_found[orig_path] = paths_found[orig_path] + 1

else:

paths_found[orig_path] = 1

if not EudoraLog.log.mbx_name() in found_attachments:

found_attachments[EudoraLog.log.mbx_name()] = []

found_attachments[EudoraLog.log.mbx_name()].append((attachment_desc, filename))

else:

attachments_missing = attachments_missing + 1

if not EudoraLog.log.mbx_name() in missing_attachments:

missing_attachments[EudoraLog.log.mbx_name()] = []

missing_attachments[EudoraLog.log.mbx_name()].append(attachment_desc)

# EudoraLog.log.warn(" FAILED to find attachment: \'" + attachment_desc + "\'" )

if re_mangled_mac.search(filename):

print "Mac pattern: %s" % (filename, )

mac_mismatches.append(filename)

if orig_path in paths_missing:

paths_missing[orig_path] = paths_missing[orig_path] + 1

else:

global edir

global attachments_listed, attachments_found, attachments_missing, attachments_dirs

global paths_found, paths_missing

global missing_attachments, found_attachments

if edir:

realfilename = edir + os.sep + filename

if not os.path.exists(realfilename):

print "Couldn't find embedded file %s" % (realfilename,)

return

else:

return

mimeinfo = mimetypes.guess_type(realfilename)

if not mimeinfo[0]:

(mimetype, mimesubtype) = ('application', 'octet-stream')

else:

(mimetype, mimesubtype) = mimeinfo[0].split('/')

if os.path.isfile(realfilename):

fp = open(realfilename, 'rb')

try:

if mimetype == 'application' or mimetype == 'video':

msg = MIMEApplication(fp.read(), _subtype=mimesubtype)

elif mimetype == 'image':

msg = MIMEImage(fp.read(), _subtype=mimesubtype)

elif mimetype == 'text':

msg = MIMEText(fp.read(), _subtype=mimesubtype)

elif mimetype == 'audio':

msg = MIMEAudio(fp.read(), _subtype=mimesubtype)

else:

EudoraLog.log.error("Unrecognized mime type '%s' while processing attachment '%s'" % (mimeinfo[0], filename))

return

finally:

fp.close()

if cid:

msg.add_header('Content-ID', cid)

msg.add_header('Content-Disposition', 'inline', filename=filename)

else:

msg.add_header('Content-Disposition', 'attachment', filename=filename)