##language:zh
'''
pmsg-scon.py
'''

-- Zoom.Quiet [<<DateTime(2004-09-04T04:12:41Z)>>]
<<TableOfContents>>
{{{#!python
from minimic.message import bytemsg
import struct
import zlib
import cPickle
pickle cPickle


class minimicPMessage(bytemsg.ByteMessage):
    """minimicP 消息基类"""
    def __init__(self):
        # 消息头
        self.head = bytemsg.ByteMessageHead(self)
        # 消息体
        self.body = bytemsg.ByteMessageBody(self)
        # 消息工具
        self.msgutilcls = minimicPMessageUtil
        # 协议名称
        self.protocolname = 'minimicp'
        # 当前的消息名称
        self.msgname = ''

    def pack_minimicp_connect(self, fields):
        """connect报文打包"""
        message = struct.pack('6s16sI8s',
                fields['system_id'], \
                fields['auth_source'], \
                fields['version'], \
                fields['time_stamp'])
        len = len(fields['test'])
        message += struct.pack('I'+str(len)+'s', \
            len, \
            fields['test'])
        zdata = zlib.compress(field['zip'])
        len = len(zdata)
        message += struct.pack('I'+str(len)+'s', \
            len, \
            zdata)
        zdata = zlib.compress(pickle.dumps(field['szip']))
        len = len(zdata)
        message += struct.pack('I'+str(len)+'s', \
            len, \
            zdata)
        return message
        
    def unpack_minimicp_connect(self, packet):
        """connect报文解包"""
        stt = '6s16sI8s'
        len = struct.calcsize(stt)
        self.body.fields['system_id'], \
            self.body.fields['auth_source'], \
            self.body.fields['version'], \
            self.body.fields['time_stamp'] = \
            struct.unpack(stt,packet[:len])
    
        packet = packet[len:]
        len = struct.unpack('I', packet[:4])
        packet = packet[4:]
        self.body.fields['test'] = struct.unpack(str(len)+'s', packet[:len])
        packet = packet[len:]
        len = struct.unpack('I', packet[:4])
        packet = packet[4:]
        self.body.fields['zip'] = zlib.decompress( \
            struct.unpack(str(len)+'s', packet[:len]))
        packet = packet[len:]
        len = struct.unpack('I', packet[:4])
        packet = packet[4:]
        self.body.fields['szip'] = pickle.loads( \
            zlib.decompress(struct.unpack(str(len)+'s', packet[:len])))

    def pack_minimicp_connect_resp(self, fields):
        """connect_resp报文打包"""
        message = struct.pack('II',
                fields['status'], \
                fields['version'])
        return message
        
    def unpack_minimicp_connect_resp(self, packet):
        """connect_resp报文解包"""
        stt = 'II'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            self.body.fields['version'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_terminate(self, fields):
        """terminate报文体为空"""
        return None

    def unpack_minimicp_terminate(self, packet):
        """terminate报文体为空"""
        pass
					
    def pack_minimicp_terminate_resp(self, fields):
        """terminate_resp报文体为空"""
        return None

    def unpack_minimicp_terminate_resp(self, packet):
        """terminate_resp报文体为空"""
        pass
					
    def pack_minimicp_add_user(self, fields):
        """add_user报文打包"""
        message = struct.pack('32s',
                fields['uid'])
        return message
        
    def unpack_minimicp_add_user(self, packet):
        """add_user报文解包"""
        stt = '32s'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_add_user_resp(self, fields):
        """add_user_resp报文打包"""
        message = struct.pack('I',
                fields['status'])
        return message
        
    def unpack_minimicp_add_user_resp(self, packet):
        """add_user_resp报文解包"""
        stt = 'I'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_del_user(self, fields):
        """del_user报文打包"""
        message = struct.pack('32s',
                fields['uid'])
        return message
        
    def unpack_minimicp_del_user(self, packet):
        """del_user报文解包"""
        stt = '32s'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_del_user_resp(self, fields):
        """del_user_resp报文打包"""
        message = struct.pack('I',
                fields['status'])
        return message
        
    def unpack_minimicp_del_user_resp(self, packet):
        """del_user_resp报文解包"""
        stt = 'I'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_add_mail(self, fields):
        """add_mail报文打包"""
        message = struct.pack('32s32s64s72s72s16sII',
                fields['uid'], \
                fields['foldername'], \
                fields['filename'], \
                fields['subject'], \
                fields['mailfrom'], \
                fields['date'], \
                fields['size'], \
                fields['flag'])
        return message
        
    def unpack_minimicp_add_mail(self, packet):
        """add_mail报文解包"""
        stt = '32s32s64s72s72s16sII'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['filename'], \
            self.body.fields['subject'], \
            self.body.fields['mailfrom'], \
            self.body.fields['date'], \
            self.body.fields['size'], \
            self.body.fields['flag'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_add_mail_resp(self, fields):
        """add_mail_resp报文打包"""
        message = struct.pack('I',
                fields['status'])
        return message
        
    def unpack_minimicp_add_mail_resp(self, packet):
        """add_mail_resp报文解包"""
        stt = 'I'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_del_mail(self, fields):
        """del_mail报文打包"""
        message = struct.pack('32s32s64s',
                fields['uid'], \
                fields['foldername'], \
                fields['filename'])
        return message
        
    def unpack_minimicp_del_mail(self, packet):
        """del_mail报文解包"""
        stt = '32s32s64s'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['filename'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_del_mail_resp(self, fields):
        """del_mail_resp报文打包"""
        message = struct.pack('I',
                fields['status'])
        return message
        
    def unpack_minimicp_del_mail_resp(self, packet):
        """del_mail_resp报文解包"""
        stt = 'I'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_get_webmail_list(self, fields):
        """get_webmail_list报文打包"""
        message = struct.pack('32s32sIII',
                fields['uid'], \
                fields['foldername'], \
                fields['dataid'], \
                fields['flag'], \
                fields['mailnum'])
        return message
        
    def unpack_minimicp_get_webmail_list(self, packet):
        """get_webmail_list报文解包"""
        stt = '32s32sIII'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['dataid'], \
            self.body.fields['flag'], \
            self.body.fields['mailnum'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_get_webmail_list_resp(self, fields):
        """
        """
        if fields['status'] == 0:
            start = struct.pack('III',
                fields['status'], \
                fields['dataid'], \
                fields['order'])
            
            len = len(fields['test'])
            start += struct.pack('I'+str(len)+'s', \
                len, \
                fields['test'])
            zdata = zlib.compress(fields['zip'])
            len = len(zdata)
            start += struct.pack('I'+str(len)+'s', \
                len, zdata)
            zdata = zlib.compress(pickle.dumps(fields['szip']))
            len = len(zdata)
            start += struct.pack('I'+str(len)+'s', \
                len,zdata)
            body = ''
            body += struct.pack('I', len(fields['maillist']))
            i = 0
            while i < len(fields['maillist']):
                body += struct.pack('64s16sII', \
                    fields['maillist'][i]['filename'], \
                    fields['maillist'][i]['date'], \
                    fields['maillist'][i]['size'], \
                    fields['maillist'][i]['flag'])
                len = len(fields['maillist'][i]['subject'])
                body += struct.pack('I'+str(len)+'s', \
                    len, \
                    fields['maillist'][i]['subject'])
                len = len(fields['maillist'][i]['mailfrom'])
                body += struct.pack('I'+str(len)+'s', \
                    len, \
                    fields['maillist'][i]['mailfrom'])
                i += 1
            return start+body
        else:
            return struct.pack('I', \
                fields['status'])

    def unpack_minimicp_get_webmail_list_resp(self, packet):
        """
        """
        (self.body.fields['status'],) = struct.unpack('I', packet)
        if self.body.fields['status'] == 0:
            stt  = 'III'
            len = struct.calcsize(stt)
            self.body.fields['status'], \
                self.body.fields['dataid'], \
                self.body.fields['order'] = \
                struct.unpack(stt, packet[:len])
            
            packet = packet[len:]
            len = struct.unpack('I', packet[:4])
            packet = packet[4:]
            self.body.fields['test'] = struct.unpack(str(len)+'s', packet[:len])
            
            packet = packet[len:]
            len = struct.unpack('I', packet[:4])
            packet = packet[4:]
            self.body.fields['zip'] = \
                zlib.decompress(struct.unpack(str(len)+'s', packet[:len]))
            packet = packet[len:]
            len = struct.unpack('I', packet[:4])
            packet = packet[4:]
            self.body.fields['szip'] = \
                pickle.loads(zlib.decompress(struct.unpack(str(len)+'s', packet[:len])))
            # "F"浮动数据开始    
            maillistlen = struct.unpack('I', packet[:4])
            self.body.fields['maillist'] = []
            i = 0
            fixedstt = '64s16sII'
            fixedlen = struct.calcsize(fixedstt)
            while i < maillistlen:
                self.body.fields['maillist'][i]['filename'], \
                    self.body.fields['maillist'][i]['date'], \
                    self.body.fields['maillist'][i]['size'], \
                    fields['maillist'][i]['flag'] = \
                    struct.unpack(fixedstt, packet[:fixedlen])
                packet = packet[fixedlen:]
                
                len = struct.unpack('I', packet[:4])
                packet = packet[4:]
                self.body.fields['maillist'][i]['subject'] = struct.unpack(str(len)+'s', packet[:len])
                packet = packet[len:]
                
                len = struct.unpack('I', packet[:4])
                packet = packet[4:]
                self.body.fields['maillist'][i]['mailfrom'] = struct.unpack(str(len)+'s', packet[:len])
                packet = packet[len:]
                
                i += 1
        else:
            pass
						
    def pack_minimicp_get_popmail_list(self, fields):
        """get_popmail_list报文打包"""
        message = struct.pack('32s',
                fields['uid'])
        return message
        
    def unpack_minimicp_get_popmail_list(self, packet):
        """get_popmail_list报文解包"""
        stt = '32s'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_get_popmail_list_resp(self, fields):
        """get_popmail_list_resp报文打包"""
        message = struct.pack('II',
                fields['mailnum'], \
                fields['status'])
        return message
        
    def unpack_minimicp_get_popmail_list_resp(self, packet):
        """get_popmail_list_resp报文解包"""
        stt = 'II'
        len = struct.calcsize(stt)
        self.body.fields['mailnum'], \
            self.body.fields['status'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_move_mail(self, fields):
        """move_mail报文打包"""
        message = struct.pack('32s32s32sI',
                fields['uid'], \
                fields['foldername'], \
                fields['oldfoldername'], \
                fields['filename'])
        return message
        
    def unpack_minimicp_move_mail(self, packet):
        """move_mail报文解包"""
        stt = '32s32s32sI'
        len = struct.calcsize(stt)
        self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['oldfoldername'], \
            self.body.fields['filename'] = \
            struct.unpack(stt,packet[:len])
    
    def pack_minimicp_move_mail_resp(self, fields):
        """move_mail_resp报文打包"""
        message = struct.pack('I',
                fields['status'])
        return message
        
    def unpack_minimicp_move_mail_resp(self, packet):
        """move_mail_resp报文解包"""
        stt = 'I'
        len = struct.calcsize(stt)
        self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
    

class minimicMessageHead(bytemsg.ByteMessageHead):
    """minimicP消息的消息头抽像类"""
    def __init__(self, parent):
        # 长度
        self.length = 8
        # 命令ID
        self.id = 0
        # 他爹
        self.parent = parent

    def __len__(self):
        """包头定长8"""
        return 8

    def setId(self,id):
        """设置命令ID"""
        self.id = id

    def setLength(self, length):
        """包的整长"""
        self.length = length

    def loadHead(self, header):
        """转换一个PDU (protocol data unit)到一个消息头
        消息头的格式为length(4字节)、commandid（4字节），共8字节长度
        """
        self.length,self.id = struct.unpack('>II', header)
    
    def packed(self):
        """转换一个消息头为二进制流
        消息头的格式为length(4字节)、commandid（4字节，共12字节长度
        """
        return struct.pack('>II', self.length, self.id)

    def __str__(self):
        """字符串化"""
        plist = []
        plist.append("消息ID:%s" % self.id)
        plist.append("消息长度：%s" % self.length)
        return reduce(lambda x,y: x + "\n" + y, plist)

class minimicPMessageUtil(bytemsg.ByteMessageUtil):
    """minimicP消息处理工具类"""
    def __init__(self):
        pass

# minimicP Message定义
minimicPMessageUtil.commandinfo = {    
    0x00000001L : 'connect',	###    
    0xff000001L : 'connect_resp',	###    
    0x00000002L : 'terminate',	###    
    0xff000002L : 'terminate_resp',	###    
    0x00000021L : 'add_user',	###    
    0xff000021L : 'add_user_resp',	###    
    0x00000015L : 'del_user',	###    
    0xff000015L : 'del_user_resp',	###    
    0x00000017L : 'add_mail',	###    
    0xff000017L : 'add_mail_resp',	###    
    0x00000018L : 'del_mail',	###    
    0xff000018L : 'del_mail_resp',	###    
    0x00000013L : 'get_webmail_list',	###    
    0xff000013L : 'get_webmail_list_resp',	###    
    0x00000014L : 'get_popmail_list',	###    
    0xff000014L : 'get_popmail_list_resp',	###    
    0x00000019L : 'move_mail',	###    
    0xff000019L : 'move_mail_resp'	###        
    }

# 通过名称查出消息ID的结构定义
minimicPMessageUtil.nametoid = {}
for k in minimicPMessageUtil.commandinfo.keys():
    minimicPMessageUtil.nametoid[minimicPMessageUtil.commandinfo[k]] = k

		

}}}