DptClient

# Embedded file name: .\build\pyi.win32\dpt_main\out00-PYZ.pyz\dpt_client
import sys
import os
path = os.path.dirname(os.path.realpath(__file__))
sys.path.append(path)
from ctypes import *
import json
import random
import binascii
import string
import base64
import time
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from ui_dpt import _translate
from restful_lib import Connection
DEGEST_SIZE = 32
RSC_ORDER_INFO = '/order_info'
RSC_PRODUCTION = '/chip_with_sn_production'
BURN_HDCP_PROTECT_KEY_SUCCESS = 0
BURN_HDCP_PROTECT_KEY_FAILED = 1
BURN_PVR_SECRET_KEY_SUCCESS = 2
BURN_PVR_SECRET_KEY_FAILED = 3
BURN_EJTAG_KEY_SUCCESS = 4
BURN_EJTAG_KEY_FAILED = 5
BURN_HDCP_CHUNK_SUCCESS = 6
BURN_HDCP_CHUNK_ALREADY_BURNED = 7
BURN_HDCP_CHUNK_FAILED = 8
BURN_CIPLUS_CHUNK_SUCCESS = 9
BURN_CIPLUS_CHUNK_ALREADY_BURNED = 10
BURN_CIPLUS_CHUNK_FAILED = 11
BURN_CHIPSN_SUCCESS = 12
BURN_CHIPSN_FAILED = 13

def tr(msg):
    return QCoreApplication.translate('@default', msg)


BURN_MSG_TR = [tr('burn hdcp protect key success'),
 tr('burn hdcp protect key failed'),
 tr('burn pvr secret key success'),
 tr('burn pvr secret key failed'),
 tr('burn ejtag key success'),
 tr('burn ejtag key failed'),
 tr('burn hdcp chunk success'),
 tr('burn hdcp chunk already burned'),
 tr('burn hdcp chunk failed'),
 tr('burn ciplus chunk success'),
 tr('burn ciplus chunk already burned'),
 tr('burn ciplus chunk failed'),
 tr('burn chip sn success'),
 tr('burn chip sn failed')]
BURN_MSG = ['burn hdcp protect key success',
 'burn hdcp protect key failed',
 'burn pvr secret key success',
 'burn pvr secret key failed',
 'burn ejtag key success',
 'burn ejtag key failed',
 'burn hdcp chunk success',
 'burn hdcp chunk already burned',
 'burn hdcp chunk failed',
 'burn ciplus chunk success',
 'burn ciplus chunk already burned',
 'burn ciplus chunk failed',
 'burn chip sn success',
 'burn chip sn failed']

class ProductionParam(Structure):
    _fields_ = [('e_chip_sn', c_char_p),
     ('hdcp_protect_key', c_char_p),
     ('pvr_secret_key', c_char_p),
     ('ejtag_key', c_char_p),
     ('hdcp_chunk', c_char_p),
     ('ciplus_chunk', c_char_p),
     ('digest_len', c_uint32),
     ('len_chip_sn', c_uint32),
     ('len_e_chip_sn', c_uint32),
     ('len_hdcp_protect_key', c_uint32),
     ('len_pvr_secret_key', c_uint32),
     ('len_ejtag_key', c_uint32),
     ('len_hdcp_chunk', c_uint32),
     ('len_ciplus_chunk', c_uint32)]


class DptClient:

    def __init__(self, worker):
        if not isinstance(worker, DptClientWorker):
            return
        self.worker = worker
        self.api = worker.api
        self.server = Connection(base_url=self.api, disable_ssl_certificate_validation=True)
        libfile = os.getcwd() + '/Mp_Serial.dll'
        self.serial = CDLL(libfile)
        self.serial.production_init.argtypes = [c_uint32, c_void_p]
        self.serial.production_read_chip_sn.argtypes = [c_char_p, c_uint32]
        self.serial.production_burn_process.argtypes = [c_void_p]
        self.serial.sign_chip_sn.argtypes = [c_char_p,
         c_char_p,
         c_uint32,
         c_void_p]

        def lib_msg_callback(msg_code, param):
            if msg_code >= 0 and msg_code <= BURN_CHIPSN_FAILED:
                txt = self.worker.tr(BURN_MSG[msg_code])
                self.worker.emit(SIGNAL('msg_out'), 0, txt)

        pdispatch_callback = CFUNCTYPE(c_void_p, c_uint32, c_uint32)
        self.pshow_msg_handle = pdispatch_callback(lib_msg_callback)
        self.serial_inited = False

    def request_production_info(self, key = ''):
        if key == '':
            self.error = self.worker.tr('Error: request_production_info empty Production Key')
            return
        args = {}
        args['key'] = key
        try:
            resp = self.server.request_get(resource=RSC_ORDER_INFO, args=args, headers={'content-type': 'application/json',
             'accept': 'application/json'})
        except Exception as e:
            self.error = self.worker.tr('Error: request_production_info Connect to Server Failed!')
            return

        status = resp[u'headers']['status']
        if status != '200':
            self.error = resp[u'headers']['reason']
            return
        self.key = key
        self.order_info = json.loads(resp[u'body'])
        return self.order_info

    def request_key_data(self, chipsn = '', successed = 0):
        if chipsn == '':
            self.error = self.worker.tr('Error: request_key_data empty chipsn')
            return
        elif self.key == '':
            self.error = self.worker.tr('Error: request_key_data empty production key')
            return
        else:
            server = self.server
            chipsn_sign = ''
            data_in = c_char_p(chipsn)
            in_size = c_uint32(len(chipsn))
            out_size = c_uint32(in_size.value + DEGEST_SIZE)
            data_out = create_string_buffer(out_size.value)
            if 0 == self.serial.sign_chip_sn(data_in, data_out, in_size, byref(out_size)):
                chipsn_sign = string_at(data_out, out_size.value)
            else:
                self.error = self.worker.tr('Error: request_key_data sign chip sn failed!')
                return
            chipsn_sign = base64.b64encode(chipsn_sign)
            args = {}
            args['key'] = self.key
            args['chip_sn'] = chipsn_sign
            if successed != 0:
                args['successed'] = 1
            try:
                resp = server.request_get(resource=RSC_PRODUCTION, args=args, headers={'content-type': 'application/json',
                 'accept': 'application/json'})
            except (IOError, OSError):
                self.error = self.worker.tr('Error: request_key_data Connect to Server Failed!')
                return

            status = resp[u'headers']['status']
            if status != '200' and status != '201':
                self.error = resp[u'headers']['reason']
                return
            data = dict(json.loads(resp[u'body']))
            if successed == 1:
                return data
            if self.order_info['chipsn'] != 0:
                if not data.has_key('echipsn') or data['echipsn'] == None or data['echipsn'] == '':
                    self.error = self.worker.tr('Error: request_key_data Model need echipsn, but server not return echipsn data')
                    return
            if self.order_info['hdcp'] != 0:
                if not data.has_key('hdcp_protect') or not data.has_key('hdcp_chunk') or data['hdcp_protect'] == None or data['hdcp_protect'] == '' or data['hdcp_chunk'] == None or data['hdcp_chunk'] == '':
                    self.error = self.worker.tr('Error: request_key_data Model need hdcp key, but server not return hdcp data')
                    return
            if self.order_info['ciplus'] != 0:
                if not data.has_key('pvr_secret') or not data.has_key('ejtag') or not data.has_key('ciplus_chunk') or data['pvr_secret'] == None or data['pvr_secret'] == '' or data['ejtag'] == None or data['ejtag'] == '' or data['ciplus_chunk'] == None or data['ciplus_chunk'] == '':
                    self.error = self.worker.tr('Error: request_key_data Model need ciplus key, but server not return ciplus data')
                    return
            return data

    def serial_burn_key_data(self, chip_sn = '', data = {}):
        if chip_sn == '' or data == {}:
            self.error = self.worker.tr('Error: serial_burn_key_data empty chipsn or data')
            return False
        if not self.serial_inited:
            self.error = self.worker.tr('Error: serial_burn_key_data serial not inited')
            return False
        param = ProductionParam()
        param.digest_len = c_uint32(DEGEST_SIZE)
        param.len_chip_sn = c_uint32(self.order_info['chipsn_len'])
        if data.has_key('echipsn') and len(data['echipsn']) > 0:
            e_chip_sn = base64.b64decode(data['echipsn'])
            param.e_chip_sn = c_char_p(e_chip_sn)
            param.len_e_chip_sn = c_uint32(len(e_chip_sn) - self.order_info['chipsn_len'] - DEGEST_SIZE)
        else:
            param.e_chip_sn = c_char_p(0)
            param.len_e_chip_sn = c_uint32(0)
        if data.has_key('hdcp_protect') and len(data['hdcp_protect']) > 0:
            hdcp_protect = base64.b64decode(data['hdcp_protect'])
            param.hdcp_protect_key = c_char_p(hdcp_protect)
            param.len_hdcp_protect_key = c_uint32(len(hdcp_protect))
        else:
            param.hdcp_protect_key = c_char_p(0)
            param.len_hdcp_protect_key = c_uint32(0)
        if data.has_key('pvr_secret') and len(data['pvr_secret']) > 0:
            pvr_secret = base64.b64decode(data['pvr_secret'])
            param.pvr_secret_key = c_char_p(pvr_secret)
            param.len_pvr_secret_key = c_uint32(len(pvr_secret))
        else:
            param.pvr_secret_key = c_char_p(0)
            param.len_pvr_secret_key = c_uint32(0)
        if data.has_key('ejtag') and len(data['ejtag']) > 0:
            ejtag = base64.b64decode(data['ejtag'])
            param.ejtag_key = c_char_p(ejtag)
            param.len_ejtag_key = c_uint32(len(ejtag))
        else:
            param.ejtag_key = c_char_p(0)
            param.len_ejtag_key = c_uint32(0)
        if data.has_key('hdcp_chunk') and len(data['hdcp_chunk']) > 0:
            hdcp_chunk = base64.b64decode(data['hdcp_chunk'])
            param.hdcp_chunk = c_char_p(hdcp_chunk)
            param.len_hdcp_chunk = c_uint32(len(hdcp_chunk))
        else:
            param.hdcp_chunk = c_char_p(0)
            param.len_hdcp_chunk = c_uint32(0)
        if data.has_key('ciplus_chunk') and len(data['ciplus_chunk']) > 0:
            ciplus_chunk = base64.b64decode(data['ciplus_chunk'])
            param.ciplus_chunk = c_char_p(ciplus_chunk)
            param.len_ciplus_chunk = c_uint32(len(ciplus_chunk))
        ret = self.serial.production_burn_process(byref(param))
        if ret == 0:
            return True
        self.error = self.worker.tr('Error: serial_burn_key_data Failed, ') + str(ret)
        return False

    def serial_read_chipsn(self, chip_sn_len = 0):
        if chip_sn_len == 0:
            self.error = self.worker.tr('Error: serial_read_chipsn chip_sn_len == 0')
            return
        if not self.serial_inited:
            self.error = self.worker.tr('Error: serial_read_chipsn serial not inited')
            return
        chip_sn_size = c_uint32(chip_sn_len)
        chip_sn_buff = create_string_buffer(chip_sn_size.value)
        ret = self.serial.production_read_chip_sn(chip_sn_buff, chip_sn_size)
        if ret == 0:
            chip_sn = string_at(chip_sn_buff, chip_sn_size.value)
            return chip_sn

    def serial_init(self, port = 0):
        self.port = port
        p = c_ulong()
        p.value = port
        ret = self.serial.production_init(p, self.pshow_msg_handle)
        if ret != 0:
            self.error = self.worker.tr('Error: serial_init Open serial port COM') + str(self.port) + self.worker.tr('Failed!')
            return False
        self.serial_inited = True
        return True

    def serial_deinit(self):
        if not self.serial_inited:
            return True
        ret = self.serial.production_deinit()
        if ret != 0:
            self.error = self.worker.tr('Error: serial_deinit Close COM') + str(self.port) + self.worker.tr('Failed!')
            return False
        self.serial_inited = False
        return True


class DptClientWorker(QThread):

    def __init__(self, parent = None):
        super(DptClientWorker, self).__init__(parent)
        self.stoped = False

    def __del__(self):
        self.port = 0
        self.key = ''
        self.stoped = True
        self.wait()

    def set_param(self, api = '', port = 0, key = ''):
        self.api = api
        self.port = port
        self.key = key

    def stop(self):
        self.stoped = True

    def isStoped(self):
        return self.stoped

    def run(self):
        self.stoped = False
        if self.port == 0 or self.key == '':
            self.emit(SIGNAL('msg_out'), 0, self.tr('Error: DptClientWorker wrong port or production key!'))
            return
        else:
            self.client = DptClient(self)
            c = self.client
            if not c.serial_init(self.port):
                self.emit(SIGNAL('msg_out'), 0, c.error)
                return
            self.emit(SIGNAL('msg_out'), 0, self.tr('Serial init success!'))
            if None == c.request_production_info(self.key):
                self.emit(SIGNAL('msg_out'), 0, c.error)
                if not c.serial_deinit():
                    self.emit(SIGNAL('msg_out'), 0, c.error)
                return
            self.emit(SIGNAL('msg_out'), 0, self.tr('Connect to server success!'))
            self.emit(SIGNAL('update_info'), c.order_info)
            self.emit(SIGNAL('msg_out'), 0, self.tr('Listening on serial port') + str(self.port))
            clean = 0
            trycnt = 0
            pre_chipsn = 0
            pre_successed = 0
            while not self.stoped:
                chipsn = c.serial_read_chipsn(c.order_info['chipsn_len'])
                if chipsn == None:
                    continue
                if pre_chipsn == chipsn and pre_successed == 1:
                    continue
                if pre_chipsn != chipsn:
                    self.emit(SIGNAL('update_result'), 0)
                    pre_chipsn = chipsn
                    pre_successed = 0
                start_time = time.time()
                if clean == 1:
                    self.emit(SIGNAL('msg_out'), clean, '')
                clean = 1
                self.emit(SIGNAL('msg_out'), 0, self.tr('Receive new chipsn from serial port!'))
                result = c.request_key_data(chipsn, 0)
                if result == None:
                    self.emit(SIGNAL('msg_out'), 0, c.error)
                    if c.error == 'Error: This chip sn already producted':
                        pre_successed = 1
                        self.emit(SIGNAL('update_result'), 9999)
                    continue
                if not result.has_key('successed'):
                    self.emit(SIGNAL('msg_out'), 0, self.tr('Get encrypted data from server success!'))
                    trycnt = trycnt + 1
                    if not c.serial_burn_key_data(chipsn, result):
                        self.emit(SIGNAL('msg_out'), 0, c.error)
                        if trycnt < 2:
                            continue
                    trycnt = 0
                    ret = c.request_key_data(chipsn, 1)
                    if ret == None:
                        self.emit(SIGNAL('msg_out'), 0, c.error)
                        continue
                    if not dict(ret).has_key('successed') or dict(ret)['successed'] != 1:
                        self.emit(SIGNAL('msg_out'), 0, self.tr('Error: server return wrong data!'))
                        continue
                    number = dict(ret)['number']
                    producted = dict(ret)['producted']
                    self.emit(SIGNAL('update_num'), number, producted)
                    self.emit(SIGNAL('update_result'), 9999)
                    self.emit(SIGNAL('msg_out'), 0, self.tr('Burn Success!'))
                    pre_successed = 1
                    end_time = time.time()
                    timeused = int(end_time - start_time)
                    timemsg = 'used time: %d seconds' % timeused
                    if producted == number:
                        self.emit(SIGNAL('msg_out'), 0, self.tr('This order already finished!'))
                        break

            if not c.serial_deinit():
                self.emit(SIGNAL('msg_out'), 0, c.error)
            return


def update_order_info(info):
    print info


def msg_out(x, msg):
    print str(x) + ': ' + msg


def update_num(total, producted):
    print str(total) + ', ' + str(producted)