Tvheadend

#!/usr/bin/env python

#

# Copyright (C) 2012 Adam Sutton <[email protected]>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, version 3 of the License.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

"""

This is a very simple HTSP client library written in python mainly just

for demonstration purposes.

Much of the code is pretty rough, but might help people get started

with communicating with HTSP server

"""

# ###########################################################################

# Utilities

# ###########################################################################

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])

# ###########################################################################

# HTSMSG Binary handler

#

# Note: this will work with the python native types:

#   dict => HMF_MAP

#   list => HMF_LIST

#   str  => HMF_STR

#   int  => HMF_S64

#

# Note: BIN/STR are both equated to str in python

# ###########################################################################

# HTSMSG types

HMF_MAP  = 1

HMF_S64  = 2

HMF_STR  = 3

HMF_BIN  = 4

HMF_LIST = 5

# Convert python to HTSMSG type

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')

# Size for field

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

# Recursively determine size of message

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

# Write out field in binary form

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

# Serialize a htsmsg

def htsmsg_binary_serialize ( msg ):

  cnt  = htsmsg_binary_count(msg)

  return int2bin(cnt) + htsmsg_binary_write(msg)

# Deserialize an htsmsg

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 >= 0:

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

        i    = i - 1

    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

# ###########################################################################

# HTSP Client

# ###########################################################################

HTSP_PROTO_VERSION = 5

# Create passwd digest

def htsp_digest ( user, passwd, chal ):

  import hashlib

  ret = hashlib.sha1(passwd + chal).digest()

  return ret

# Client object

class HTSPClient:

  # Setup connection

  def __init__ ( self, addr, name = 'HTSP PyClient' ):

    # Setup

    self._sock = socket.create_connection(addr)

    self._sock.settimeout(1.0)

    self._name = name

    self._auth = None

    # Handshake

    self.hello()

  # Send

  def _send ( self, func, args ):

    args['method'] = func

    self._sock.send(htsmsg_binary_serialize(args))

  # Receive

  def _recv ( self ):

    num  = bin2int(self._sock.recv(4))

    data = ''

    while len(data) != num:

      tmp  = self._sock.recv(num - len(data))

      if not tmp: raise Exception('htsp_recv() failed')

      data = data + tmp

    return htsmsg_binary_deserialize(data)

  # Setup

  def hello ( self ):

    args = {

      'htspversion' : HTSP_PROTO_VERSION,

      'clientname'  : self._name

    }

    self._send('hello', args)

    resp = self._recv()

    # Validate

    if resp['htspversion'] != HTSP_PROTO_VERSION:

      raise Exception('version mismatch')

    self._auth = resp['challenge']

    # Output info

    print 'Connected to: %s (%s)' % (resp['servername'], resp['serverversion'])

    return resp

  # Authenticate

  def authenticate ( self, user, passwd = None ):

    args = {

      'challenge' : self._auth,

      'username'  : user,

    }

    if passwd:

      args['digest'] = htsp_digest(user, passwd, self._auth)

    self._send('authenticate', args)

    resp = self._recv()

    # Validate

    import pprint

    pprint.pprint(resp)

#

# Test

#

if __name__ == '__main__':

  import sys, socket

  host = 'localhost'

  if len(sys.argv) > 1: host = sys.argv[1]

  htsp = HTSPClient((host, 9982))

  htsp.authenticate('xbmc', 'xbmc')