Tvheadend

#!/usr/bin/env python

#

# Really noddy script to connect to HTSP server

#

#

# translation of htsmsg_binary.c

#

# Note: source message should be a standard python types, dict, list, string

# and integer

#

HMF_MAP  = 1

HMF_S64  = 2

HMF_STR  = 3

HMF_BIN  = 4

HMF_LIST = 5

def hmf_type ( f ):

  if type(f) == list:

    return HMF_MAP

  elif type(f) == dict:

    return HMF_LIST

  elif type(f) == str:

    return HMF_STR

  elif type(f) == int:

    return HMF_S64

  else:

    raise Exception('invalid type')

def int2bin ( i ):

  return chr(i >> 24 & 0xFF) + chr(i >> 16 & 0xFF)\

       + chr(i >> 16 & 0xFF) + chr(i & 0xFF)

def bin2int ( d ):

  return (ord(d[0]) << 24) + (ord(d[1]) << 16)\

       + (ord(d[2]) <<  8) + ord(d[3])

def _htsmsg_binary_count ( f ):

  ret = 0

  if type(f) == str:

    ret = ret + len(f)

  elif type(f) == int:

    while (f):

      ret = ret + 1

      f   = f >> 8

  elif type(f) == list or type(f) == map:

    ret = ret + htsmsg_binary_count(f)

  else:

    raise Exception('invalid data type')

  return ret

def htsmsg_binary_count ( msg ):

  ret = 0

  lst = type(msg) == list

  for f in msg:

    ret = ret + 6

    if not lst: 

      ret = ret + len(f)

      f   = msg[f]

    ret = ret + _htsmsg_binary_count(f)

  return ret

def htsmsg_binary_write ( msg ):

  ret = ''

  lst = type(msg) == list

  for f in msg:

    na = ''

    if not lst:

      na = f

      f  = msg[f]

    ret = ret + chr(hmf_type(f))

    ret = ret + chr(len(na) & 0xFF)

    l   = _htsmsg_binary_count(f)

    ret = ret + int2bin(l)

    ret = ret + na

    if type(f) == list or type(f) == dict:

      ret = ret + htsmsg_binary_write(f)

    elif type(f) == str:

      ret = ret + f

    elif type(f) == int:

      while f:

        ret = ret + chr(f & 0xFF)

        f   = f >> 8

    else:

      raise Exception('invalid type')

  return ret

def htsmsg_binary_serialize ( msg ):

  cnt  = htsmsg_binary_count(msg)

  return int2bin(cnt) + htsmsg_binary_write(msg)

def htsmsg_binary_deserialize ( data ):

  msg = {}

  while len(data) > 5:

    typ  = ord(data[0])

    nlen = ord(data[1])

    dlen = bin2int(data[2:6])

    data = data[6:]

    if len < nlen + dlen: raise Exception('not enough data')

    name = data[:nlen]

    data = data[nlen:]

    if typ in [ HMF_STR, HMF_BIN ]:

      item = data[:dlen]

    elif typ == HMF_S64:

      item = 0

      i    = dlen - 1

      while i:

        item = (item << 8) | data[i]

    elif typ in [ HMF_LIST, HMF_MAP ]:

      item = htsmsg_binary_deserialize(data[:dlen])

    else:

      raise Exception('invalid data type %d' % typ)

    msg[name] = item

    data      = data[dlen:]

  return msg

def htsp_read ( s ):

  data = s.recv(4)

  if len(data) != 4: raise Exception('not enough data')

  num  = bin2int(data)

  print 'length = %d' %num

  data = s.recv(num)

  if len(data) != num: raise Exception('not enough data')

  # TODO: this should be done properly to handle partial read() calls

  return data

def htsp_method ( func, args ):

  args['method'] = func

  return htsmsg_binary_serialize(args)

#

# Test

#

if __name__ == '__main__':

  import socket, pprint

  s    = socket.create_connection(('localhost', 9982))

  helo = {

    'htspversion' : 5,

    'clientname'  : 'HTSP PyDemo'

  }

  data = htsp_method('hello', helo)

  s.send(data)

  data = htsp_read(s)

  print data

  msg  = htsmsg_binary_deserialize(data)

  pprint.pprint(msg)