title: Troubleshooting "TypeError: ord() expected string of length 1, but int found"
body: <pre><code>ERROR : TypeError: ord() expected string of length 1, but int found
  </code></pre>
  
  <p>I am getting this error while compiling the program. </p>
  
  <pre><code> File "C:\Users\Administrator\Desktop\tracer1.py", line 129, in &lt;module&gt;
      get_route("www.google.com")
    File "C:\Users\Administrator\Desktop\tracer1.py", line 85, in get_route
      d = build_packet()
    File "C:\Users\Administrator\Desktop\tracer1.py", line 62, in build_packet
      myChecksum = checksum(header + data)
    File "C:\Users\Administrator\Desktop\tracer1.py", line 28, in checksum
      thisVal = ord(str[count+1]) * 256 + ord(str[count])
  **TypeError: ord() expected string of length 1, but int found**
  </code></pre>
  
  <p>the program is to find the traceroute using ICMP</p>
  
  <pre><code>from socket import *
  import socket
  import os
  import sys
  import struct
  import time
  import select
  import binascii
  import ctypes
  ICMP_ECHO_REQUEST = 8
  MAX_HOPS = 30
  TIMEOUT = 2.0
  TRIES = 2
  
  # The packet that we shall send to each router along the path is the ICMP echo
  # request packet, which is exactly what we had used in the ICMP ping exercise.
  # We shall use the same packet that we built in the Ping exercise
  
  ctypes.windll.shell32.IsUserAnAdmin()
  print (ctypes.windll.shell32.IsUserAnAdmin())
  
  def checksum(str):
      csum = 0
      countTo = (len(str) / 2) * 2
      count = 0
  
      while count &lt; countTo:
          thisVal = ord(str[count+1]) * 256 + ord(str[count])
          csum = csum + thisVal
          csum = csum &amp; 0xffffffff
          count = count + 2
  
      if countTo &lt; len(str):
          csum = csum + ord(str[len(str) - 1])
          csum = csum &amp; 0xffffffff
  
      csum = (csum &gt;&gt; 16) + (csum &amp; 0xffff)
      csum = csum + (csum &gt;&gt; 16)
      answer = ~csum
      answer = answer &amp; 0xffff
      answer = answer &gt;&gt; 8 | (answer &lt;&lt; 8 &amp; 0xff00)
      return answer
  
  def build_packet():
      # In the sendOnePing() method of the ICMP Ping exercise ,firstly the header of our
      # packet to be sent was made, secondly the checksum was appended to the header and
      # then finally the complete packet was sent to the destination.
  
      # Make the header in a similar way to the ping exercise.
      # Header is type (8), code (8), checksum (16), id (16), sequence (16)
      myChecksum = 0
      pid = os.getpid() &amp; 0xFFFF
  
      # Make a dummy header with a 0 checksum.
      # struct -- Interpret strings as packed binary data
      header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, myChecksum, pid, 1)
      #header = struct.pack("!HHHHH", ICMP_ECHO_REQUEST, 0, myChecksum, pid, 1)
      data = struct.pack("d", time.time())
  
      # Calculate the checksum on the data and the dummy header.
      # Append checksum to the header.
      myChecksum = checksum(header + data)    
      if sys.platform == 'darwin':
          myChecksum = socket.htons(myChecksum) &amp; 0xffff
          #Convert 16-bit integers from host to network byte order.
      else:
          myChecksum = htons(myChecksum)
  
      packet = header + data
      return packet
  
  def get_route(hostname):
      timeLeft = TIMEOUT
      for ttl in range(1,MAX_HOPS):
          for tries in range(TRIES):
              destAddr = socket.gethostbyname(hostname)
              #Fill in start
              # Make a raw socket named mySocket
              mySocket = socket.socket(AF_INET, SOCK_RAW, getprotobyname("icmp"))
              mySocket.bind(("", 12000));
              #Fill in end
              mySocket.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, struct.pack('I', ttl))
              mySocket.settimeout(TIMEOUT)
              try:
                  d = build_packet()
                  mySocket.sendto(d, (hostname, 0))
                  t = time.time()
                  startedSelect = time.time()
                  whatReady = select.select([mySocket], [], [], timeLeft)
                  howLongInSelect = (time.time() - startedSelect)
                  if whatReady[0] == []: # Timeout
                      print ("*    *    * Request timed out.")
  
                  recvPacket, addr = mySocket.recvfrom(1024)
                  print ("addr")
                  timeReceived = time.time()
                  timeLeft = timeLeft - howLongInSelect
                  if timeLeft &lt;= 0:
                      print ("*    *    * Request timed out.")
              except socket.timeout:
                  continue
              else:
                  #Fill in start
                  # Fetch the icmp type from the IP packet
                  print( struct.calcsize("bbHHhd"))
                  request_code, request_type, checksum, packet_id, \
                      sequence, timeSent, data = struct.unpack("bbHHhd", recvPacket,0)
                  #Fill in end
  
                  if request_type == 11:
                      bytes = struct.calcsize("d")
                      timeSent = struct.unpack("d", recvPacket[28:28 + bytes])[0]
                      print (" %d   rtt=%.0f ms %s" % (ttl,(timeReceived -t)*1000, addr[0]))
                  elif request_type == 3:
                      bytes = struct.calcsize("d")
                      timeSent = struct.unpack("d", recvPacket[28:28 + bytes])[0]
                      print (" %d   rtt=%.0f ms %s" % (ttl,(timeReceived -t)*1000, addr[0]))
                  elif request_type == 0:
                      bytes = struct.calcsize("d")
                      timeSent = struct.unpack("d", recvPacket[28:28 + bytes])[0]
                      print (" %d   rtt=%.0f ms %s" % (ttl,(timeReceived -timeSent)*1000, addr[0]))
                      return
                  else:
                      print ("error")
                      break
              finally:
                  mySocket.close()
  
  get_route("www.google.com")
  </code></pre>