cmppmsg.py

python写的cmpp报文解析代码, 其中只实现了部分常用的报文

#coding=gbk

import struct, hashlib, socket, types

def ToHexStr(str):
    unit_len = 4
    l = len(str)
    rr = l/unit_len
    if l % unit_len > 0:
        rr += 1
        str = str.ljust(rr*unit_len, '\xff')
    x=[]
    for i in range(rr):
        (n0,n1,n2,n3)=struct.unpack('BBBB', str[i*unit_len:(i+1)*unit_len])
        x.append("%02x%02x%02x%02x"%(n0,n1,n2,n3))
    return "".join(x)

def FromHexStr (s):
    l = len(s)
    ss=[]
    for i in range(l/8):
        x = (int(s[i*8:i*8+2], 16), int(s[i*8+2:i*8+4], 16), int(s[i*8+4:i*8+6], 16), int(s[i*8+6:i*8+8], 16))
        s1 = struct.pack('BBBB', x[0],x[1],x[2],x[3])
        ss.append(s1)

    if l % 8 > 0:
        x = (l / 8) * 8
        s1 = s[x:l]
        for i in range(len(s1)/2):
            s2 = s1[i*2:i*2+2]
            ss.append(struct.pack('B', int(s2,16)))

    return "".join(ss)

def ReadPkt(sock):
    if type(sock) != socket.socket:
        return
    hlen = 12
    s = sock.recv(hlen)
    if len(s) != hlen:
        print 'invalid read header len', repr(s)
        return
    (pkt_len, cmdid, seq) = struct.unpack('III', s)
    pkt_len = socket.ntohl(pkt_len)
    cmdid = socket.ntohl(cmdid)
    if pkt_len <= hlen:
        return
    pkt_len -= hlen
    while pkt_len > 0:
        sb = sock.recv(pkt_len)
        if len(sb) == 0:
            return
        s = s + sb
        pkt_len -= len(sb)
    #print "RCV:", ToHexStr(s)
    return (cmdid, s)
       
class Base:
    CMPP_CONNECT        =   0x00000001
    CMPP_CONNECT_REP    =   0x80000001
    CMPP_TERMINATE      =   0x00000002
    CMPP_TERMINATE_REP  =   0x80000002
    CMPP_SUBMIT         =   0x00000004
    CMPP_SUBMIT_REP     =   0x80000004
    CMPP_DELIVER        =   0x00000005
    CMPP_DELIVER_REP    =   0x80000005
    CMPP_ACTIVE         =   0x00000008
    CMPP_ACTIVE_REP     =   0x80000008
    HEAD_LEN = 12

    def __init__ (self):
        self.len   = 0
        self.cmdid = 0
        self.seq   = 0
        
    def ToStr(self):
        return struct.pack('III', socket.htonl(self.len),
                            socket.htonl(self.cmdid),
                             socket.htonl(self.seq))
    def FromStr(self, str):
        (self.len, self.cmdid, self.seq) = struct.unpack('III', str[0:12])
        self.len = socket.ntohl(self.len)
        self.cmdid = socket.ntohl(self.cmdid)
        self.seq = socket.ntohl(self.seq)

class Connect(Base):
    def __init__ (self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_CONNECT
        self.len = Base.HEAD_LEN + 27
        self.spid=''
        self.auth = ''
        self.ver = 0x20
        self.timestamp = 8080808

    def ToStr (self, seq, spid, pwd):
        self.spid = spid
        self.seq = seq
        #先计算auth
        m=hashlib.md5()
        auth_src = '%s\0\0\0\0\0\0\0\0\0%s%010d'%(self.spid, pwd, socket.htonl(self.timestamp))
        print "auth_src:", repr(auth_src)
        m.update(auth_src)
        self.auth = m.digest()
        return Base.ToStr(self) + struct.pack('6s16sB',
                    self.spid, self.auth, self.ver) + struct.pack('I',socket.htonl(self.timestamp))
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.spid, self.auth, self.ver, self.timestamp) = struct.unpack('6s16sBI', str[Base.HEAD_LEN:])
        self.timestamp = socket.ntohl(self.timestamp)
                    
class ConnectRep(Base):
    def __init__ (self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_CONNECT_REP
        self.len = Base.HEAD_LEN + 18
        self.status = 0
        self.auth = ''
        self.ver = 0x20

    def ToStr (self, status, version, pwd, connpkt):
        self.status = status
        self.seq = connpkt.seq
        m = hashlib.md5()
        m.update("".join((status, connpkt.auth, pwd)))
        self.auth = m.digest()
        self.ver = version
        return Base.ToStr(self) + struct.pack('B16sB', self.status, self.auth, self.ver)
    
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.status, self.auth, self.ver) = struct.unpack('B16sB', str[Base.HEAD_LEN:])

class Active(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_ACTIVE
        self.len = Base.HEAD_LEN
    def ToStr(self, seq):
        self.seq = seq
        return Base.ToStr(self)
    def FromStr(self, str):
        Base.FromStr(self, str)
        
class ActiveRep(Base):
    def __init__(self):
        Base.__init(self)
        self.cmdid = Base.CMPP_ACTIVE_REP
        self.len = Base.HEAD_LEN + 1
        self.reserve = 1
    def ToStr(self, seq, reserve):
        self.seq = seq
        self.reserve = reserve
        return Base.ToStr(self) + struct.pack('B', self.reserve)
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.reserve,)=struct.unpack('B', str[Base.HEAD_LEN:])

class Terminate(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_TERMINATE
        self.len = Base.HEAD_LEN
    def ToStr(self, seq):
        self.seq = seq
        return Base.ToStr(self)
    def FromStr(self, str):
        Base.FromStr(self, str)
        
class TerminateRep(Base):
    def __init__(self):
        Base.__init(self)
        self.cmdid = Base.CMPP_TERMINATE_REP
        self.len = Base.HEAD_LEN
    def ToStr(self, seq):
        self.seq = seq
        return Base.ToStr(self)
    def FromStr(self, str):
        Base.FromStr(self, str)
        
class Submit(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_SUBMIT
        self.msg_id=0
        self.pk_total=1
        self.pk_number=1
        self.registered_delivery=0
        self.msg_level=0
        self.service_id=''
        self.fee_usertype=0
        self.fee_terminal_id=''
        self.tp_pid=0
        self.tp_udhi=0
        self.msg_fmt=0
        self.msg_src=''
        self.feetype='00'
        self.feecode=''
        self.valid_time=''
        self.at_time=''
        self.src_id=''
        self.destusr_tl=0
        self.dest_terminal_id=[]
        self.msg_length=0
        self.msg_content=''
        self.reserve=''

    def ToStr(self, seq, src_id, dest_id, msg, msg_fmt=0, registered_delivery=1, service_id='hh', tp_udhi=0):
        self.seq = seq
        self.registered_delivery=registered_delivery
        self.service_id = service_id
        self.tp_udhi = tp_udhi
        self.msg_fmt = msg_fmt
        self.src_id = src_id
        if type(dest_id) == types.StringType:
            self.destusr_tl = 1
            self.dest_terminal_id = (dest_id.ljust(21, '\0')[0:21])
        else:
            self.destusr_tl = len(dest_id)
            a=[]
            for i in dest_id:
                a.append(i.ljust(21, '\0')[0:21])
            self.dest_terminal_id = a
        self.fee_terminal_id = self.dest_terminal_id[0]
        self.msg_length = len(msg)
        self.msg_content = msg
        self.len = Base.HEAD_LEN + 117 + self.destusr_tl * 21 + 1 + self.msg_length + 8
        
        strHeader = Base.ToStr(self)
        strBody = struct.pack('QBBBB10sB21sBBB6s2s6s17s17s21sB%dsB%ds8s'%(self.destusr_tl*21, self.msg_length),
                              self.msg_id, self.pk_total, self.pk_number, self.registered_delivery, self.msg_level,
                              self.service_id, self.fee_usertype, self.fee_terminal_id, self.tp_pid, self.tp_udhi,
                              self.msg_fmt, self.msg_src, self.feetype, self.feecode, self.valid_time, self.at_time,
                              self.src_id, self.destusr_tl, "".join(self.dest_terminal_id), self.msg_length,
                              self.msg_content, self.reserve)
        return strHeader + strBody
    
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.msg_id, self.pk_total, self.pk_number, self.registered_delivery, self.msg_level,
                              self.service_id, self.fee_usertype, self.fee_trninal_id, self.tp_pid, self.tp_udhi,
                              self.msg_fmt, self.msg_src, self.feetype, self.feecode, self.valid_time, self.at_time,
                              self.src_id, self.destusr_tl) = struct.unpack('QBBBB10sB21sBBB6s2s6s17s17s21sB', str[Base.HEADER_LEN:])
        pos = 129
        destids = str[pos:pos+self.destusr_tl*21]
        pos += len(destids)
        (self.msg_lenth,)=struct.unpack('B', str[pos:pos+1])
        pos += 1
        self.msg_content = str[pos:pos+self.msg_length]

class SubmitRep(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_SUBMIT_REP
        self.len = Base.HEAD_LEN + 9
        self.msgid = 0
        self.result = 0
    def ToStr(self, seq, msgid, result):
        self.seq = seq
        self.msgid = msgid
        self.result = result
        return Base.ToStr(self) + struct.pack('QB', self.msgid, self.result)
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.msgid, self.result)=struct.unpack('QB', str[Base.HEAD_LEN:])


class Deliver(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_DELIVER
        self.msg_id=0
        self.dest_id=''
        self.service_id=''
        self.tp_pid=0
        self.tp_udhi=0
        self.msg_fmt=0
        self.src_terminal_id=''
        self.registered_delivery=0
        self.msg_length=0
        self.msg_content=''
        self.reserved='\0\0\0\0\0\0\0\0'

    def ToStr(self, seq, msgid, dest_id, service_id, msg_fmt, src_id, registered_delivery, msg, tp_udhi=0):
        self.seq = seq
        self.msg_id = msgid
        self.dest_id = dest_id
        self.service_id = service_id
        self.tp_udhi = tp_udhi
        self.msg_fmt = msg_fmt
        self.src_terminal_id = src_id
        self.registered_delivery = registered_delivery
        self.msg_length = len(msg)
        self.msg_content = msg
        self.len = Base.HEAD_LEN + 65 + self.msg_length + 8
        return Base.ToStr(self) + struct.pack('Q21s10sBBB21sBB',
                self.msg_id, self.dest_id, self.service_id, self.tp_pid, self.tp_udhi,
                self.msg_fmt, self.src_terminal_id, self.registered_delivery,
                 self.msg_length) + self.msg_content + self.reserved
    def FromStr(self, str):
        Base.FromStr(self, str)
        pos = Base.HEAD_LEN
        (self.msg_id, self.dest_id, self.service_id, self.tp_pid, self.tp_udhi,
                self.msg_fmt, self.src_terminal_id, self.registered_delivery,
                 self.msg_length)=struct.unpack('Q21s10sBBB21sBB', str[pos:pos+65])
        pos = 77
        self.msg_content = str[pos:pos+self.msg_length]

class DeliverRep(Base):
    def __init__(self):
        Base.__init__(self)
        self.cmdid = Base.CMPP_DELIVER_REP
        self.len = Base.HEAD_LEN + 9
        self.msgid = 0
        self.result = 0
    def ToStr(self, seq, msgid, result):
        self.seq = seq
        self.msgid = msgid
        self.result = result
        return Base.ToStr(self) + struct.pack('QB', self.msgid, self.result)
    def FromStr(self, str):
        Base.FromStr(self, str)
        (self.msgid, self.result)=struct.unpack('QB', str[Base.HEAD_LEN:])