def decode_part (self, m, as_utf8 = 0):
ct = m.getmaintype("text")
if ct != "text": as_utf8 = 0
body = m.get_payload()
if not isinstance(body, StringType):
body = str(body)
encoding = string.lower(m.get('content-transfer-encoding', '7bit'))
if encoding == "quoted-printable":
from quopri import decode
## how annoying
inb = StringIO(body)
outb = StringIO()
decode(inb, outb)
body = outb.getvalue()
elif encoding == "base64":
from base64 import decodestring
try:
body = decodestring(body)
except:
pass
if ct == "text":
# don't allow embedded nulls in text parts
body = string.replace(body, '\0', '')
if as_utf8: return to_utf8(body, self.charset(m))
return body
def quopri_decode(input, errors = 'strict'):
assert errors == 'strict'
f = StringIO(str(input))
g = StringIO()
quopri.decode(f, g)
output = g.getvalue()
return (output, len(input))
def test_decode(self):
for p, e in self.STRINGS:
infp = cStringIO.StringIO(e)
outfp = cStringIO.StringIO()
if not test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=317834"):
quopri.decode(infp, outfp) #binascii.a2b_qp() not implemented which is needed in function decode()
self.assertTrue(outfp.getvalue() == p)
def mime_unpack(self, input, stack):
entity = mimetools.Message(input)
stack = (entity,) + stack
if entity.getmaintype() == 'multipart':
self.parts.append(MessagePart(None, None, stack))
boundary = entity.getparam('boundary')
if boundary:
input.push(boundary)
while input.next():
self.mime_unpack(input, stack)
input.pop()
elif entity.gettype() == 'message/rfc822':
self.parts.append(MessagePart(None, None, stack))
self.mime_unpack(input, stack)
else:
name = get_filename(entity)
work = tempfile.mktemp()
cte = entity.getencoding()
if cte == 'quoted-printable':
output = cStringIO.StringIO()
quopri.decode(input, output)
elif cte == 'base64':
output = cStringIO.StringIO()
base64_decode(input, output)
else:
output = None
if output:
output.reset()
if entity.gettype() == "application/x-gzip" or \
(name and name.endswith(".gz")):
work2 = tempfile.mktemp()
tmp2 = open(work2+".gz", "w")
tmp2.write(output.read())
tmp2.close()
inst = popen2.Popen4("gunzip %s.gz" % work2)
data = inst.fromchild.read()
if inst.wait() != 0:
self.write_fatal(_("Uncompressing your submission with gzip has failed. gzip said:\n%s\n") % data)
try:
os.unlink(work2+".gz")
except OSError:
pass
return
output=open(work2)
os.unlink(work2)
if name and name.endswith(".gz"):
name=name[:-3]
tmp = open(work,"w")
tmp.write(output.read())
tmp.close()
del output
self.simple_unpack(open(work), name, stack)
os.remove(work)
else:
self.simple_unpack(input, name, stack)
def _qdecode(s):
import quopri as _quopri
if not s:
return s
infp = StringIO(s)
outfp = StringIO()
_quopri.decode(infp, outfp)
value = outfp.getvalue()
if not s.endswith('\n') and value.endswith('\n'):
return value[:-1]
return value
def quopri_decode(input, errors='strict'):
"""Decode the input, returning a tuple (output object, length consumed).
errors defines the error handling to apply. It defaults to
'strict' handling which is the only currently supported
error handling for this codec.
"""
assert errors == 'strict'
f = StringIO(str(input))
g = StringIO()
quopri.decode(f, g)
output = g.getvalue()
return (output, len(input))
def decode(encoding, s):
if encoding == '7bit' or encoding == '8bit' or encoding == 'binary':
return s
elif encoding == 'quoted-printable':
import quopri
ifp = StringIO.StringIO(s)
ofp = StringIO.StringIO()
quopri.decode(ifp, ofp)
return ofp.getvalue()
elif encoding == 'base64':
import base64
return base64.decodestring(s)
else:
raise Error("Unknown encoding %s" % repr(encoding))
def decode(encoding, s):
if encoding == '7bit' or encoding == '8bit' or encoding == 'binary':
return s
elif encoding == 'quoted-printable':
import quopri
ifp = StringIO.StringIO(s)
ofp = StringIO.StringIO()
quopri.decode(ifp, ofp)
return ofp.getvalue()
elif encoding == 'base64':
import base64
return base64.decodestring(s)
else:
raise Error("Unknown encoding %s" % repr(encoding))
def quopri_decode(input, errors='strict'):
"""Decode the input, returning a tuple (output object, length consumed).
errors defines the error handling to apply. It defaults to
'strict' handling which is the only currently supported
error handling for this codec.
"""
assert errors == 'strict'
f = StringIO(str(input))
g = StringIO()
quopri.decode(f, g)
output = g.getvalue()
return (output, len(input))
def __init__(self, reader, a): sqmail.gui.viewer.Viewer.__init__(self, reader, a, "textmessage") font = gtk.load_font(sqmail.preferences.get_textmessagefont()) # Ensure the text box is 80 columns wide. width = gtk.gdk_char_width(font, "m")*82 # The text box is guaranteed to be empty. self.viewer_widget.messagetext.freeze() self.viewer_widget.messagetext.set_usize(width, 0) if (self.attachment[1] == "text/quoted-printable"): infp = cStringIO.StringIO(self.attachment[2]) outfp = cStringIO.StringIO() quopri.decode(infp, outfp) body = outfp.getvalue() else: body = self.attachment[2] self.viewer_widget.messagetext.insert(font, None, None, body) self.viewer_widget.messagetext.thaw()
def __init__(self, reader, a):
sqmail.gui.viewer.Viewer.__init__(self, reader, a, "htmlmessage")
# Glade doesn't do the GtkXmHTML widget yet. So we need to add
# it manually.
self.htmlwidget = gnome.xmhtml.GtkXmHTML()
self.viewer_widget.frame.add(self.htmlwidget)
self.htmlwidget.show()
self.htmlwidget.freeze()
if self.attachment[1] == "text/quoted-printable":
infp = cStringIO.StringIO(self.attachment[2])
outfp = cStringIO.StringIO()
quopri.decode(infp, outfp)
body = outfp.getvalue()
else:
body = self.attachment[2]
self.htmlwidget.set_allow_images(1)
self.htmlwidget.source(body)
self.htmlwidget.thaw()
def _decode(self, headers, fileobj):
encoding = headers[-1].get_all("content-transfer-encoding", ["7bit"])[0]
encoding = encoding.lower()
if encoding == "base64":
try:
data = base64.b64decode(fileobj.read())
except TypeError as error:
self.log.error("Base64 decoding failed ({0})".format(error))
idiokit.stop(False)
return StringIO(data)
if encoding == "quoted-printable":
output = StringIO()
quopri.decode(fileobj, output)
output.seek(0)
return output
return fileobj
def parseFrame(self, frame):
# Parse a passed-in frame for name-value pairs.
# Same as from_rfc_822_format in cgi-bin/PubSub/EventFormat.pm .
message = {}
while len(frame):
pos = string.index(frame, "\n")
header = None
value = None
header = frame[:pos]
frame = frame[pos + 1:]
if not pos:
# The rest of the frame is the "kn_payload" value.
name = "kn_payload"
value = frame
frame = ""
else:
# Now we've parsed out a header line. Split into name and value.
sep = string.index(header, ":")
nameEscaped = header[:sep]
valueEscaped = string.lstrip(header[sep + 1:])
# Decode them.
nameEscapedStream = cStringIO.StringIO(nameEscaped)
valueEscapedStream = cStringIO.StringIO(valueEscaped)
nameStream = cStringIO.StringIO()
valueStream = cStringIO.StringIO()
quopri.decode(nameEscapedStream, nameStream)
quopri.decode(valueEscapedStream, valueStream)
nameStream.seek(0)
valueStream.seek(0)
name = nameStream.read()
value = valueStream.read()
# Decode UTF-8.
nameU = unicode(name, "UTF-8", "replace")
valueU = unicode(value, "UTF-8", "replace")
# Add this name-value pair to the message.
if message.has_key(nameU):
valueU = message[nameU] + ", " + valueU
message[nameU] = valueU
continue
self.onMessage(message)
def parseFrame(self, frame):
# Parse a passed-in frame for name-value pairs.
# Same as from_rfc_822_format in cgi-bin/PubSub/EventFormat.pm .
message = { }
while len(frame):
pos = string.index(frame, "\n")
header = None
value = None
header = frame[ : pos ]
frame = frame[ pos + 1 : ]
if not pos:
# The rest of the frame is the "kn_payload" value.
name = "kn_payload"
value = frame
frame = ""
else:
# Now we've parsed out a header line. Split into name and value.
sep = string.index(header, ":")
nameEscaped = header[ : sep ]
valueEscaped = string.lstrip(header[ sep + 1 : ])
# Decode them.
nameEscapedStream = cStringIO.StringIO(nameEscaped)
valueEscapedStream = cStringIO.StringIO(valueEscaped)
nameStream = cStringIO.StringIO()
valueStream = cStringIO.StringIO()
quopri.decode(nameEscapedStream, nameStream)
quopri.decode(valueEscapedStream, valueStream)
nameStream.seek(0)
valueStream.seek(0)
name = nameStream.read()
value = valueStream.read()
# Decode UTF-8.
nameU = unicode(name, "UTF-8", "replace")
valueU = unicode(value, "UTF-8", "replace")
# Add this name-value pair to the message.
if message.has_key(nameU):
valueU = message[nameU] + ", " + valueU
message[nameU] = valueU
continue
self.onMessage(message)
def fetch_file(self, f):
"""Fetch the body part into a file-like object."""
# XXX This is icky. This means that on multipart messages we will
# fetch everything but on non-multipart messages we only fetch the
# first element. I also tried creating a fake multi-part body but
# that ends up in an even worse abstraction once you hand it out to
# the json encoding code.
if (not self['content_type'].startswith('multipart/')
and self['partnumber'] == ''):
# RfC 3501: The part number of a single non-multipart message is
# always 1.
partnumber = '1'
else:
partnumber = self['partnumber']
encoding = self.get('encoding')
if encoding in ['base64', 'quoted-printable']:
# XXX Make StringIO first, swap to temporary file on a size threshold.
encoded = tempfile.NamedTemporaryFile()
else:
encoded = f
for chunk_no in itertools.count():
data = _fetch(self.server, self.message.parent, self.message.UID,
'BODY[%s]' % partnumber, chunk_no)
if data == '':
break
if data == gocept.imapapi.parser.NIL:
raise gocept.imapapi.interfaces.BrokenMIMEPart()
encoded.write(data)
encoded.seek(0)
if encoding == 'base64':
base64.decode(encoded, f)
elif encoding == 'quoted-printable':
quopri.decode(encoded, f)
f.seek(0)
def decode(input, output, encoding):
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if encoding in ('7bit', '8bit'):
return output.write(input.read())
else:
raise ValueError, \
'unknown Content-Transfer-Encoding: %s' % encoding
def decode(input, output, encoding):
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if decodetab.has_key(encoding):
pipethrough(input, decodetab[encoding], output)
else:
raise ValueError, \
'unknown Content-Transfer-Encoding: %s' % encoding
def decode(input, output, encoding):
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if decodetab.has_key(encoding):
pipethrough(input, decodetab[encoding], output)
else:
raise ValueError, \
'unknown Content-Transfer-Encoding: %s' % encoding
def decode(input, output, encoding):
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if encoding in ('7bit', '8bit'):
return output.write(input.read())
if encoding in decodetab:
pipethrough(input, decodetab[encoding], output)
else:
raise ValueError, 'unknown Content-Transfer-Encoding: %s' % encoding
def decode(input, output, encoding):
"""Decode common content-transfer-encodings (base64, quopri, uuencode)."""
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if encoding in ('7bit', '8bit'):
return output.write(input.read())
if encoding in decodetab:
pipethrough(input, decodetab[encoding], output)
else:
raise ValueError, 'unknown Content-Transfer-Encoding: %s' % encoding
def decode(input, output, encoding):
"""Decode common content-transfer-encodings (base64, quopri, uuencode)."""
if encoding == 'base64':
import base64
return base64.decode(input, output)
if encoding == 'quoted-printable':
import quopri
return quopri.decode(input, output)
if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
import uu
return uu.decode(input, output)
if encoding in ('7bit', '8bit'):
output.write(input.read())
if decodetab.has_key(encoding):
pipethrough(input, decodetab[encoding], output)
else:
raise ValueError, \
'unknown Content-Transfer-Encoding: %s' % encoding
def parse_body(currentLine, line, lines, boundary):
offset=1
nextFirstLine = lines[currentLine+1]
# if nextFirstLine.startswith("Content-Type"):
encoding = None
indexPlainText = nextFirstLine.find("text/plain")
if indexPlainText == -1:
return encoding, None
else:
offset = offset + 1
nextOfNextLine = lines[currentLine+2]
if nextOfNextLine.startswith("Content-Transfer-Encoding"):
encoding = nextOfNextLine.split(':')[1].strip()
offset = offset + 1
textLines=lines[currentLine + offset:]
actualText=[]
for txtLine in textLines:
if txtLine == "--{}".format(boundary) or txtLine == "--{}--".format(boundary):
break
else:
actualText.append(txtLine)
text = "\r\n".join(actualText)
logger.info("text found")
logger.info(text)
logger.info("~"*8)
#deal with encoding
if encoding == "base64":
text = base64.b64decode(text)
#elif encoding == "7bit" or encoding == "8bit":
# text = quopri.decodestring(text)
elif encoding == "quoted-printable":
try:
text = quopri.decode(text)
except:
pass
elif encoding == "uuencode" or encoding == "x-uuencode" or encoding == "uue" or encoding == "x-uue":
text = uu.decode(text)
return encoding, text
def quopri_decode(input, errors='strict'):
assert errors == 'strict'
f = BytesIO(input)
g = BytesIO()
quopri.decode(f, g)
return (g.getvalue(), len(input))
def decodestring(instring):
outfile = StringIO.StringIO()
quopri.decode(StringIO.StringIO(instring), outfile)
return outfile.getvalue()
def quopri_decode(input, errors='strict'):
assert errors == 'strict'
f = BytesIO(input)
g = BytesIO()
quopri.decode(f, g)
return (g.getvalue(), len(input))
def test_decode(self):
for p, e in self.STRINGS:
infp = cStringIO.StringIO(e)
outfp = cStringIO.StringIO()
quopri.decode(infp, outfp)
self.assert_(outfp.getvalue() == p)
"""Various tools used by MIME-reading or MIME-writing programs."""
"""Codec for quoted-printable encoding.
"""Codec for quoted-printable encoding.
def test_decode(self):
for p, e in self.STRINGS:
infp = cStringIO.StringIO(e)
outfp = cStringIO.StringIO()
quopri.decode(infp, outfp)
self.assert_(outfp.getvalue() == p)
def test_decode(self):
for p, e in self.STRINGS:
infp = io.BytesIO(e)
outfp = io.BytesIO()
quopri.decode(infp, outfp)
self.assertEqual(outfp.getvalue(), p)
def test_decode(self):
for p, e in self.STRINGS:
infp = io.BytesIO(e)
outfp = io.BytesIO()
quopri.decode(infp, outfp)
self.assertEqual(outfp.getvalue(), p)
"""Various tools used by MIME-reading or MIME-writing programs."""
def quopri_decode(input, errors='strict'):
f = StringIO(str(input))
g = StringIO()
quopri.decode(f, g)
output = g.getvalue()
return (output, len(input))
def update_event(self, inp=-1):
self.set_output_val(
0, quopri.decode(self.input(0), self.input(1), self.input(2)))
def decodestring(instring): outfile = io.StringIO() quopri.decode(io.StringIO(instring), outfile) return outfile.getvalue()
def decodestring(instring):
outfile = io.BytesIO()
quopri.decode(io.BytesIO(instring.encode()), outfile)
return outfile.getvalue().decode("utf-8", "ignore")
