| #! /usr/bin/env python3 |
| |
| """Conversions to/from quoted-printable transport encoding as per RFC 1521.""" |
| |
| # (Dec 1991 version). |
| |
| __all__ = ["encode", "decode", "encodestring", "decodestring"] |
| |
| ESCAPE = b'=' |
| MAXLINESIZE = 76 |
| HEX = b'0123456789ABCDEF' |
| EMPTYSTRING = b'' |
| |
| try: |
| from binascii import a2b_qp, b2a_qp |
| except ImportError: |
| a2b_qp = None |
| b2a_qp = None |
| |
| |
| def needsquoting(c, quotetabs, header): |
| """Decide whether a particular byte ordinal needs to be quoted. |
| |
| The 'quotetabs' flag indicates whether embedded tabs and spaces should be |
| quoted. Note that line-ending tabs and spaces are always encoded, as per |
| RFC 1521. |
| """ |
| assert isinstance(c, bytes) |
| if c in b' \t': |
| return quotetabs |
| # if header, we have to escape _ because _ is used to escape space |
| if c == b'_': |
| return header |
| return c == ESCAPE or not (b' ' <= c <= b'~') |
| |
| def quote(c): |
| """Quote a single character.""" |
| assert isinstance(c, bytes) and len(c)==1 |
| c = ord(c) |
| return ESCAPE + bytes((HEX[c//16], HEX[c%16])) |
| |
| |
| |
| def encode(input, output, quotetabs, header=False): |
| """Read 'input', apply quoted-printable encoding, and write to 'output'. |
| |
| 'input' and 'output' are binary file objects. The 'quotetabs' flag |
| indicates whether embedded tabs and spaces should be quoted. Note that |
| line-ending tabs and spaces are always encoded, as per RFC 1521. |
| The 'header' flag indicates whether we are encoding spaces as _ as per RFC |
| 1522.""" |
| |
| if b2a_qp is not None: |
| data = input.read() |
| odata = b2a_qp(data, quotetabs=quotetabs, header=header) |
| output.write(odata) |
| return |
| |
| def write(s, output=output, lineEnd=b'\n'): |
| # RFC 1521 requires that the line ending in a space or tab must have |
| # that trailing character encoded. |
| if s and s[-1:] in b' \t': |
| output.write(s[:-1] + quote(s[-1:]) + lineEnd) |
| elif s == b'.': |
| output.write(quote(s) + lineEnd) |
| else: |
| output.write(s + lineEnd) |
| |
| prevline = None |
| while 1: |
| line = input.readline() |
| if not line: |
| break |
| outline = [] |
| # Strip off any readline induced trailing newline |
| stripped = b'' |
| if line[-1:] == b'\n': |
| line = line[:-1] |
| stripped = b'\n' |
| # Calculate the un-length-limited encoded line |
| for c in line: |
| c = bytes((c,)) |
| if needsquoting(c, quotetabs, header): |
| c = quote(c) |
| if header and c == b' ': |
| outline.append(b'_') |
| else: |
| outline.append(c) |
| # First, write out the previous line |
| if prevline is not None: |
| write(prevline) |
| # Now see if we need any soft line breaks because of RFC-imposed |
| # length limitations. Then do the thisline->prevline dance. |
| thisline = EMPTYSTRING.join(outline) |
| while len(thisline) > MAXLINESIZE: |
| # Don't forget to include the soft line break `=' sign in the |
| # length calculation! |
| write(thisline[:MAXLINESIZE-1], lineEnd=b'=\n') |
| thisline = thisline[MAXLINESIZE-1:] |
| # Write out the current line |
| prevline = thisline |
| # Write out the last line, without a trailing newline |
| if prevline is not None: |
| write(prevline, lineEnd=stripped) |
| |
| def encodestring(s, quotetabs=False, header=False): |
| if b2a_qp is not None: |
| return b2a_qp(s, quotetabs=quotetabs, header=header) |
| from io import BytesIO |
| infp = BytesIO(s) |
| outfp = BytesIO() |
| encode(infp, outfp, quotetabs, header) |
| return outfp.getvalue() |
| |
| |
| |
| def decode(input, output, header=False): |
| """Read 'input', apply quoted-printable decoding, and write to 'output'. |
| 'input' and 'output' are binary file objects. |
| If 'header' is true, decode underscore as space (per RFC 1522).""" |
| |
| if a2b_qp is not None: |
| data = input.read() |
| odata = a2b_qp(data, header=header) |
| output.write(odata) |
| return |
| |
| new = b'' |
| while 1: |
| line = input.readline() |
| if not line: break |
| i, n = 0, len(line) |
| if n > 0 and line[n-1:n] == b'\n': |
| partial = 0; n = n-1 |
| # Strip trailing whitespace |
| while n > 0 and line[n-1:n] in b" \t\r": |
| n = n-1 |
| else: |
| partial = 1 |
| while i < n: |
| c = line[i:i+1] |
| if c == b'_' and header: |
| new = new + b' '; i = i+1 |
| elif c != ESCAPE: |
| new = new + c; i = i+1 |
| elif i+1 == n and not partial: |
| partial = 1; break |
| elif i+1 < n and line[i+1:i+2] == ESCAPE: |
| new = new + ESCAPE; i = i+2 |
| elif i+2 < n and ishex(line[i+1:i+2]) and ishex(line[i+2:i+3]): |
| new = new + bytes((unhex(line[i+1:i+3]),)); i = i+3 |
| else: # Bad escape sequence -- leave it in |
| new = new + c; i = i+1 |
| if not partial: |
| output.write(new + b'\n') |
| new = b'' |
| if new: |
| output.write(new) |
| |
| def decodestring(s, header=False): |
| if a2b_qp is not None: |
| return a2b_qp(s, header=header) |
| from io import BytesIO |
| infp = BytesIO(s) |
| outfp = BytesIO() |
| decode(infp, outfp, header=header) |
| return outfp.getvalue() |
| |
| |
| |
| # Other helper functions |
| def ishex(c): |
| """Return true if the byte ordinal 'c' is a hexadecimal digit in ASCII.""" |
| assert isinstance(c, bytes) |
| return b'0' <= c <= b'9' or b'a' <= c <= b'f' or b'A' <= c <= b'F' |
| |
| def unhex(s): |
| """Get the integer value of a hexadecimal number.""" |
| bits = 0 |
| for c in s: |
| c = bytes((c,)) |
| if b'0' <= c <= b'9': |
| i = ord('0') |
| elif b'a' <= c <= b'f': |
| i = ord('a')-10 |
| elif b'A' <= c <= b'F': |
| i = ord(b'A')-10 |
| else: |
| assert False, "non-hex digit "+repr(c) |
| bits = bits*16 + (ord(c) - i) |
| return bits |
| |
| |
| |
| def main(): |
| import sys |
| import getopt |
| try: |
| opts, args = getopt.getopt(sys.argv[1:], 'td') |
| except getopt.error as msg: |
| sys.stdout = sys.stderr |
| print(msg) |
| print("usage: quopri [-t | -d] [file] ...") |
| print("-t: quote tabs") |
| print("-d: decode; default encode") |
| sys.exit(2) |
| deco = 0 |
| tabs = 0 |
| for o, a in opts: |
| if o == '-t': tabs = 1 |
| if o == '-d': deco = 1 |
| if tabs and deco: |
| sys.stdout = sys.stderr |
| print("-t and -d are mutually exclusive") |
| sys.exit(2) |
| if not args: args = ['-'] |
| sts = 0 |
| for file in args: |
| if file == '-': |
| fp = sys.stdin.buffer |
| else: |
| try: |
| fp = open(file, "rb") |
| except OSError as msg: |
| sys.stderr.write("%s: can't open (%s)\n" % (file, msg)) |
| sts = 1 |
| continue |
| try: |
| if deco: |
| decode(fp, sys.stdout.buffer) |
| else: |
| encode(fp, sys.stdout.buffer, tabs) |
| finally: |
| if file != '-': |
| fp.close() |
| if sts: |
| sys.exit(sts) |
| |
| |
| |
| if __name__ == '__main__': |
| main() |