pmsg-scon.py

-- Zoom.Quiet [2004-09-04 04:12:41]

Contents

   1 from minimic.message import bytemsg
   2 import struct
   3 import zlib
   4 import cPickle
   5 pickle cPickle
   6 
   7 
   8 class minimicPMessage(bytemsg.ByteMessage):
   9     """minimicP 消息基类"""
  10     def __init__(self):
  11         # 消息头
  12         self.head = bytemsg.ByteMessageHead(self)
  13         # 消息体
  14         self.body = bytemsg.ByteMessageBody(self)
  15         # 消息工具
  16         self.msgutilcls = minimicPMessageUtil
  17         # 协议名称
  18         self.protocolname = 'minimicp'
  19         # 当前的消息名称
  20         self.msgname = ''
  21 
  22     def pack_minimicp_connect(self, fields):
  23         """connect报文打包"""
  24         message = struct.pack('6s16sI8s',
  25                 fields['system_id'], \
                fields['auth_source'], \
                fields['version'], \
                fields['time_stamp'])
  26         len = len(fields['test'])
  27         message += struct.pack('I'+str(len)+'s', \
            len, \
            fields['test'])
  28         zdata = zlib.compress(field['zip'])
  29         len = len(zdata)
  30         message += struct.pack('I'+str(len)+'s', \
            len, \
            zdata)
  31         zdata = zlib.compress(pickle.dumps(field['szip']))
  32         len = len(zdata)
  33         message += struct.pack('I'+str(len)+'s', \
            len, \
            zdata)
  34         return message
  35 
  36     def unpack_minimicp_connect(self, packet):
  37         """connect报文解包"""
  38         stt = '6s16sI8s'
  39         len = struct.calcsize(stt)
  40         self.body.fields['system_id'], \
            self.body.fields['auth_source'], \
            self.body.fields['version'], \
            self.body.fields['time_stamp'] = \
            struct.unpack(stt,packet[:len])
  41 
  42         packet = packet[len:]
  43         len = struct.unpack('I', packet[:4])
  44         packet = packet[4:]
  45         self.body.fields['test'] = struct.unpack(str(len)+'s', packet[:len])
  46         packet = packet[len:]
  47         len = struct.unpack('I', packet[:4])
  48         packet = packet[4:]
  49         self.body.fields['zip'] = zlib.decompress( \
            struct.unpack(str(len)+'s', packet[:len]))
  50         packet = packet[len:]
  51         len = struct.unpack('I', packet[:4])
  52         packet = packet[4:]
  53         self.body.fields['szip'] = pickle.loads( \
            zlib.decompress(struct.unpack(str(len)+'s', packet[:len])))
  54 
  55     def pack_minimicp_connect_resp(self, fields):
  56         """connect_resp报文打包"""
  57         message = struct.pack('II',
  58                 fields['status'], \
                fields['version'])
  59         return message
  60 
  61     def unpack_minimicp_connect_resp(self, packet):
  62         """connect_resp报文解包"""
  63         stt = 'II'
  64         len = struct.calcsize(stt)
  65         self.body.fields['status'], \
            self.body.fields['version'] = \
            struct.unpack(stt,packet[:len])
  66 
  67     def pack_minimicp_terminate(self, fields):
  68         """terminate报文体为空"""
  69         return None
  70 
  71     def unpack_minimicp_terminate(self, packet):
  72         """terminate报文体为空"""
  73         pass
  74 
  75     def pack_minimicp_terminate_resp(self, fields):
  76         """terminate_resp报文体为空"""
  77         return None
  78 
  79     def unpack_minimicp_terminate_resp(self, packet):
  80         """terminate_resp报文体为空"""
  81         pass
  82 
  83     def pack_minimicp_add_user(self, fields):
  84         """add_user报文打包"""
  85         message = struct.pack('32s',
  86                 fields['uid'])
  87         return message
  88 
  89     def unpack_minimicp_add_user(self, packet):
  90         """add_user报文解包"""
  91         stt = '32s'
  92         len = struct.calcsize(stt)
  93         self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
  94 
  95     def pack_minimicp_add_user_resp(self, fields):
  96         """add_user_resp报文打包"""
  97         message = struct.pack('I',
  98                 fields['status'])
  99         return message
 100 
 101     def unpack_minimicp_add_user_resp(self, packet):
 102         """add_user_resp报文解包"""
 103         stt = 'I'
 104         len = struct.calcsize(stt)
 105         self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
 106 
 107     def pack_minimicp_del_user(self, fields):
 108         """del_user报文打包"""
 109         message = struct.pack('32s',
 110                 fields['uid'])
 111         return message
 112 
 113     def unpack_minimicp_del_user(self, packet):
 114         """del_user报文解包"""
 115         stt = '32s'
 116         len = struct.calcsize(stt)
 117         self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
 118 
 119     def pack_minimicp_del_user_resp(self, fields):
 120         """del_user_resp报文打包"""
 121         message = struct.pack('I',
 122                 fields['status'])
 123         return message
 124 
 125     def unpack_minimicp_del_user_resp(self, packet):
 126         """del_user_resp报文解包"""
 127         stt = 'I'
 128         len = struct.calcsize(stt)
 129         self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
 130 
 131     def pack_minimicp_add_mail(self, fields):
 132         """add_mail报文打包"""
 133         message = struct.pack('32s32s64s72s72s16sII',
 134                 fields['uid'], \
                fields['foldername'], \
                fields['filename'], \
                fields['subject'], \
                fields['mailfrom'], \
                fields['date'], \
                fields['size'], \
                fields['flag'])
 135         return message
 136 
 137     def unpack_minimicp_add_mail(self, packet):
 138         """add_mail报文解包"""
 139         stt = '32s32s64s72s72s16sII'
 140         len = struct.calcsize(stt)
 141         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])
 142 
 143     def pack_minimicp_add_mail_resp(self, fields):
 144         """add_mail_resp报文打包"""
 145         message = struct.pack('I',
 146                 fields['status'])
 147         return message
 148 
 149     def unpack_minimicp_add_mail_resp(self, packet):
 150         """add_mail_resp报文解包"""
 151         stt = 'I'
 152         len = struct.calcsize(stt)
 153         self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
 154 
 155     def pack_minimicp_del_mail(self, fields):
 156         """del_mail报文打包"""
 157         message = struct.pack('32s32s64s',
 158                 fields['uid'], \
                fields['foldername'], \
                fields['filename'])
 159         return message
 160 
 161     def unpack_minimicp_del_mail(self, packet):
 162         """del_mail报文解包"""
 163         stt = '32s32s64s'
 164         len = struct.calcsize(stt)
 165         self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['filename'] = \
            struct.unpack(stt,packet[:len])
 166 
 167     def pack_minimicp_del_mail_resp(self, fields):
 168         """del_mail_resp报文打包"""
 169         message = struct.pack('I',
 170                 fields['status'])
 171         return message
 172 
 173     def unpack_minimicp_del_mail_resp(self, packet):
 174         """del_mail_resp报文解包"""
 175         stt = 'I'
 176         len = struct.calcsize(stt)
 177         self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
 178 
 179     def pack_minimicp_get_webmail_list(self, fields):
 180         """get_webmail_list报文打包"""
 181         message = struct.pack('32s32sIII',
 182                 fields['uid'], \
                fields['foldername'], \
                fields['dataid'], \
                fields['flag'], \
                fields['mailnum'])
 183         return message
 184 
 185     def unpack_minimicp_get_webmail_list(self, packet):
 186         """get_webmail_list报文解包"""
 187         stt = '32s32sIII'
 188         len = struct.calcsize(stt)
 189         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])
 190 
 191     def pack_minimicp_get_webmail_list_resp(self, fields):
 192         """
 193         """
 194         if fields['status'] == 0:
 195             start = struct.pack('III',
 196                 fields['status'], \
                fields['dataid'], \
                fields['order'])
 197 
 198             len = len(fields['test'])
 199             start += struct.pack('I'+str(len)+'s', \
                len, \
                fields['test'])
 200             zdata = zlib.compress(fields['zip'])
 201             len = len(zdata)
 202             start += struct.pack('I'+str(len)+'s', \
                len, zdata)
 203             zdata = zlib.compress(pickle.dumps(fields['szip']))
 204             len = len(zdata)
 205             start += struct.pack('I'+str(len)+'s', \
                len,zdata)
 206             body = ''
 207             body += struct.pack('I', len(fields['maillist']))
 208             i = 0
 209             while i < len(fields['maillist']):
 210                 body += struct.pack('64s16sII', \
                    fields['maillist'][i]['filename'], \
                    fields['maillist'][i]['date'], \
                    fields['maillist'][i]['size'], \
                    fields['maillist'][i]['flag'])
 211                 len = len(fields['maillist'][i]['subject'])
 212                 body += struct.pack('I'+str(len)+'s', \
                    len, \
                    fields['maillist'][i]['subject'])
 213                 len = len(fields['maillist'][i]['mailfrom'])
 214                 body += struct.pack('I'+str(len)+'s', \
                    len, \
                    fields['maillist'][i]['mailfrom'])
 215                 i += 1
 216             return start+body
 217         else:
 218             return struct.pack('I', \
                fields['status'])
 219 
 220     def unpack_minimicp_get_webmail_list_resp(self, packet):
 221         """
 222         """
 223         (self.body.fields['status'],) = struct.unpack('I', packet)
 224         if self.body.fields['status'] == 0:
 225             stt  = 'III'
 226             len = struct.calcsize(stt)
 227             self.body.fields['status'], \
                self.body.fields['dataid'], \
                self.body.fields['order'] = \
                struct.unpack(stt, packet[:len])
 228 
 229             packet = packet[len:]
 230             len = struct.unpack('I', packet[:4])
 231             packet = packet[4:]
 232             self.body.fields['test'] = struct.unpack(str(len)+'s', packet[:len])
 233 
 234             packet = packet[len:]
 235             len = struct.unpack('I', packet[:4])
 236             packet = packet[4:]
 237             self.body.fields['zip'] = \
                zlib.decompress(struct.unpack(str(len)+'s', packet[:len]))
 238             packet = packet[len:]
 239             len = struct.unpack('I', packet[:4])
 240             packet = packet[4:]
 241             self.body.fields['szip'] = \
                pickle.loads(zlib.decompress(struct.unpack(str(len)+'s', packet[:len])))
 242             # "F"浮动数据开始    
 243             maillistlen = struct.unpack('I', packet[:4])
 244             self.body.fields['maillist'] = []
 245             i = 0
 246             fixedstt = '64s16sII'
 247             fixedlen = struct.calcsize(fixedstt)
 248             while i < maillistlen:
 249                 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])
 250                 packet = packet[fixedlen:]
 251 
 252                 len = struct.unpack('I', packet[:4])
 253                 packet = packet[4:]
 254                 self.body.fields['maillist'][i]['subject'] = struct.unpack(str(len)+'s', packet[:len])
 255                 packet = packet[len:]
 256 
 257                 len = struct.unpack('I', packet[:4])
 258                 packet = packet[4:]
 259                 self.body.fields['maillist'][i]['mailfrom'] = struct.unpack(str(len)+'s', packet[:len])
 260                 packet = packet[len:]
 261 
 262                 i += 1
 263         else:
 264             pass
 265 
 266     def pack_minimicp_get_popmail_list(self, fields):
 267         """get_popmail_list报文打包"""
 268         message = struct.pack('32s',
 269                 fields['uid'])
 270         return message
 271 
 272     def unpack_minimicp_get_popmail_list(self, packet):
 273         """get_popmail_list报文解包"""
 274         stt = '32s'
 275         len = struct.calcsize(stt)
 276         self.body.fields['uid'], \
            struct.unpack(stt,packet[:len])
 277 
 278     def pack_minimicp_get_popmail_list_resp(self, fields):
 279         """get_popmail_list_resp报文打包"""
 280         message = struct.pack('II',
 281                 fields['mailnum'], \
                fields['status'])
 282         return message
 283 
 284     def unpack_minimicp_get_popmail_list_resp(self, packet):
 285         """get_popmail_list_resp报文解包"""
 286         stt = 'II'
 287         len = struct.calcsize(stt)
 288         self.body.fields['mailnum'], \
            self.body.fields['status'] = \
            struct.unpack(stt,packet[:len])
 289 
 290     def pack_minimicp_move_mail(self, fields):
 291         """move_mail报文打包"""
 292         message = struct.pack('32s32s32sI',
 293                 fields['uid'], \
                fields['foldername'], \
                fields['oldfoldername'], \
                fields['filename'])
 294         return message
 295 
 296     def unpack_minimicp_move_mail(self, packet):
 297         """move_mail报文解包"""
 298         stt = '32s32s32sI'
 299         len = struct.calcsize(stt)
 300         self.body.fields['uid'], \
            self.body.fields['foldername'], \
            self.body.fields['oldfoldername'], \
            self.body.fields['filename'] = \
            struct.unpack(stt,packet[:len])
 301 
 302     def pack_minimicp_move_mail_resp(self, fields):
 303         """move_mail_resp报文打包"""
 304         message = struct.pack('I',
 305                 fields['status'])
 306         return message
 307 
 308     def unpack_minimicp_move_mail_resp(self, packet):
 309         """move_mail_resp报文解包"""
 310         stt = 'I'
 311         len = struct.calcsize(stt)
 312         self.body.fields['status'], \
            struct.unpack(stt,packet[:len])
 313 
 314 
 315 class minimicMessageHead(bytemsg.ByteMessageHead):
 316     """minimicP消息的消息头抽像类"""
 317     def __init__(self, parent):
 318         # 长度
 319         self.length = 8
 320         # 命令ID
 321         self.id = 0
 322         # 他爹
 323         self.parent = parent
 324 
 325     def __len__(self):
 326         """包头定长8"""
 327         return 8
 328 
 329     def setId(self,id):
 330         """设置命令ID"""
 331         self.id = id
 332 
 333     def setLength(self, length):
 334         """包的整长"""
 335         self.length = length
 336 
 337     def loadHead(self, header):
 338         """转换一个PDU (protocol data unit)到一个消息头
 339         消息头的格式为length(4字节)、commandid(4字节),共8字节长度
 340         """
 341         self.length,self.id = struct.unpack('>II', header)
 342 
 343     def packed(self):
 344         """转换一个消息头为二进制流
 345         消息头的格式为length(4字节)、commandid(4字节,共12字节长度
 346         """
 347         return struct.pack('>II', self.length, self.id)
 348 
 349     def __str__(self):
 350         """字符串化"""
 351         plist = []
 352         plist.append("消息ID:%s" % self.id)
 353         plist.append("消息长度:%s" % self.length)
 354         return reduce(lambda x,y: x + "\n" + y, plist)
 355 
 356 class minimicPMessageUtil(bytemsg.ByteMessageUtil):
 357     """minimicP消息处理工具类"""
 358     def __init__(self):
 359         pass
 360 
 361 # minimicP Message定义
 362 minimicPMessageUtil.commandinfo = {
 363     0x00000001L : 'connect',    ###    
 364     0xff000001L : 'connect_resp',       ###    
 365     0x00000002L : 'terminate',  ###    
 366     0xff000002L : 'terminate_resp',     ###    
 367     0x00000021L : 'add_user',   ###    
 368     0xff000021L : 'add_user_resp',      ###    
 369     0x00000015L : 'del_user',   ###    
 370     0xff000015L : 'del_user_resp',      ###    
 371     0x00000017L : 'add_mail',   ###    
 372     0xff000017L : 'add_mail_resp',      ###    
 373     0x00000018L : 'del_mail',   ###    
 374     0xff000018L : 'del_mail_resp',      ###    
 375     0x00000013L : 'get_webmail_list',   ###    
 376     0xff000013L : 'get_webmail_list_resp',      ###    
 377     0x00000014L : 'get_popmail_list',   ###    
 378     0xff000014L : 'get_popmail_list_resp',      ###    
 379     0x00000019L : 'move_mail',  ###    
 380     0xff000019L : 'move_mail_resp'      ###        
 381     }
 382 
 383 # 通过名称查出消息ID的结构定义
 384 minimicPMessageUtil.nametoid = {}
 385 for k in minimicPMessageUtil.commandinfo.keys():
 386     minimicPMessageUtil.nametoid[minimicPMessageUtil.commandinfo[k]] = k