tlslite.utils.compat

Package tlslite :: Package utils :: Module compat |
[hide private]
[frames] | no frames]

# Source Code for Module tlslite.utils.compat

     1  # Author: Trevor Perrin
     2  # See the LICENSE file for legal information regarding use of this file.
     3
     4  """Miscellaneous functions to mask Python version differences."""
     5
     6  import sys
     7  import os
     8  import math
     9  import binascii
    10
    11  if sys.version_info >= (3,0):
    12
    13 -    def compat26Str(x): return x
    14
    15      # Python 3 requires bytes instead of bytearrays for HMAC
    16
    17      # So, python 2.6 requires strings, python 3 requires 'bytes',
    18      # and python 2.7 can handle bytearrays...
    19 -    def compatHMAC(x): return bytes(x)
    20
    21 -    def raw_input(s):
    22          return input(s)
    23
    24      # So, the python3 binascii module deals with bytearrays, and python2
    25      # deals with strings...  I would rather deal with the "a" part as
    26      # strings, and the "b" part as bytearrays, regardless of python version,
    27      # so...
    28 -    def a2b_hex(s):
    29          try:
    30              b = bytearray(binascii.a2b_hex(bytearray(s, "ascii")))
    31          except Exception as e:
    32              raise SyntaxError("base16 error: %s" % e)
    33          return b
    34
    35 -    def a2b_base64(s):
    36          try:
    37              b = bytearray(binascii.a2b_base64(bytearray(s, "ascii")))
    38          except Exception as e:
    39              raise SyntaxError("base64 error: %s" % e)
    40          return b
    41
    42 -    def b2a_hex(b):
    43          return binascii.b2a_hex(b).decode("ascii")
    44
    45 -    def b2a_base64(b):
    46          return binascii.b2a_base64(b).decode("ascii")
    47
    48 -    def readStdinBinary():
    49          return sys.stdin.buffer.read()
    50
    51  else:
    52      # Python 2.6 requires strings instead of bytearrays in a couple places,
    53      # so we define this function so it does the conversion if needed.
    54      if sys.version_info < (2,7):
    55 -        def compat26Str(x): return str(x)
    56      else:
    57 -        def compat26Str(x): return x
    58
    59      # So, python 2.6 requires strings, python 3 requires 'bytes',
    60      # and python 2.7 can handle bytearrays...
    61 -    def compatHMAC(x): return compat26Str(x)
    62
    63 -    def a2b_hex(s):
    64          try:
    65              b = bytearray(binascii.a2b_hex(s))
    66          except Exception as e:
    67              raise SyntaxError("base16 error: %s" % e)
    68          return b
    69
    70 -    def a2b_base64(s):
    71          try:
    72              b = bytearray(binascii.a2b_base64(s))
    73          except Exception as e:
    74              raise SyntaxError("base64 error: %s" % e)
    75          return b
    76
    77 -    def b2a_hex(b):
    78          return binascii.b2a_hex(compat26Str(b))
    79
    80 -    def b2a_base64(b):
    81          return binascii.b2a_base64(compat26Str(b))
    82
    83  import traceback
    84 -def formatExceptionTrace(e):
    85      newStr = "".join(traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback))
    86      return newStr
    87