Source Code for Module lacewing.packetloaders.client

  1  # Copyright (c) 2011 Mathias Kaerlev. 
  2  # See LICENSE for details. 
  3   
  4  from struct import Struct 
  5   
  6  from lacewing.baseloader import _BaseLoader, _EmptyLoader 
  7  from lacewing.bitdict import BitDict 
  8  from lacewing.packetloaders.common import (_BinaryMessageMixin,  
  9      _ObjectMessageMixin) 
 10  from lacewing.packetloaders.common import (CONNECT, SET_NAME, JOIN_CHANNEL,  
 11      LEAVE_CHANNEL) 
 12   
 13  REQUEST_TYPE = Struct('<B') 
 14  FLAG_DATA = Struct('<B') 
 15  CHANNEL_DATA = Struct('<H') 
 16  SUBCHANNEL_DATA = Struct('<B') 
 17  CHANNEL_MESSAGE_DATA = Struct('<BH') 
 18  PEER_MESSAGE_DATA = Struct('<BHH') 
 19  CHANNEL_MASTER_DATA = Struct('<HBH') 
 20   
 21  MASTER_KICK, = xrange(1) 
 22   
 23  CHANNEL_FLAGS = BitDict( 
 24      'HideChannel', 
 25      'AutoClose' 
 26  ) 
 27   
 28 -class Request(_BaseLoader): 
 29      request = None 
 30      version = None 
 31      name = None 
 32      flags = None 
 33      channel = None 
 34       
 35 -    def initialize(self): 
 36          self.flags = CHANNEL_FLAGS.copy() 
 37   
 38 -    def read(self, data): 
 39          request, = REQUEST_TYPE.unpack_from(data) 
 40          data = buffer(data, 1) 
 41          self.request = request 
 42          if request == CONNECT: 
 43              self.version = str(data) 
 44          elif request == SET_NAME: 
 45              self.name = str(data) 
 46          elif request == JOIN_CHANNEL: 
 47              flags, = FLAG_DATA.unpack_from(data) 
 48              self.flags.setFlags(flags) 
 49              self.name = str(buffer(data, FLAG_DATA.size)) 
 50          elif request == LEAVE_CHANNEL: 
 51              self.channel, = CHANNEL_DATA.unpack_from(data) 
 52   
 53 -    def generate(self): 
 54          request = self.request 
 55          requestByte = REQUEST_TYPE.pack(request) 
 56          if request == CONNECT: 
 57              return requestByte + self.version 
 58          elif request == SET_NAME: 
 59              return requestByte + self.name 
 60          elif request == JOIN_CHANNEL: 
 61              return (requestByte + FLAG_DATA.pack( 
 62                  self.flags.getFlags()) + self.name) 
 63          elif request == LEAVE_CHANNEL: 
 64              return requestByte + CHANNEL_DATA.pack(self.channel) 
 65          else: 
 66              return requestByte 
 67   
 68 -class _ServerMessage(_BaseLoader): 
 69      subchannel = None 
 70 -    def read(self, data): 
 71          self.subchannel, = SUBCHANNEL_DATA.unpack_from(data) 
 72          self.readMessage(buffer(data, 1)) 
 73       
 74 -    def generate(self): 
 75          return SUBCHANNEL_DATA.pack(self.subchannel) + self.generateMessage() 
 76   
 77 -class _ChannelMessage(_BaseLoader): 
 78      subchannel = None 
 79      channel = None 
 80 -    def read(self, data): 
 81          self.subchannel, self.channel = CHANNEL_MESSAGE_DATA.unpack_from(data) 
 82          self.readMessage(buffer(data, CHANNEL_MESSAGE_DATA.size)) 
 83       
 84 -    def generate(self): 
 85          return CHANNEL_MESSAGE_DATA.pack(self.subchannel,  
 86              self.channel) + self.generateMessage() 
 87   
 88 -class _PeerMessage(_BaseLoader): 
 89      subchannel = None 
 90      channel = None 
 91      peer = None 
 92 -    def read(self, data): 
 93          (self.subchannel, self.channel,  
 94              self.peer) = PEER_MESSAGE_DATA.unpack_from(data) 
 95          self.readMessage(buffer(data, PEER_MESSAGE_DATA.size)) 
 96       
 97 -    def generate(self): 
 98          return PEER_MESSAGE_DATA.pack(self.subchannel,  
 99              self.channel, self.peer) + self.generateMessage() 
100   
101 -class BinaryServerMessage(_BinaryMessageMixin, _ServerMessage): 
102      pass 
103   
104 -class BinaryChannelMessage(_BinaryMessageMixin, _ChannelMessage): 
105      pass 
106   
107 -class BinaryPeerMessage(_BinaryMessageMixin, _PeerMessage): 
108      pass 
109   
110 -class ObjectServerMessage(_ObjectMessageMixin, _ServerMessage): 
111      pass 
112   
113 -class ObjectChannelMessage(_ObjectMessageMixin, _ChannelMessage): 
114      pass 
115   
116 -class ObjectPeerMessage(_ObjectMessageMixin, _PeerMessage): 
117      pass 
118   
119 -class UDPHello(_EmptyLoader): 
120      pass 
121   
122 -class Pong(_EmptyLoader): 
123      pass 
124   
125 -class ChannelMaster(_BaseLoader): 
126      channel = None 
127      action = None 
128      peer = None 
129   
130 -    def read(self, data): 
131          self.channel, self.action, self.peer = CHANNEL_MASTER_DATA.unpack_from( 
132              data) 
133       
134 -    def generate(self): 
135          return CHANNEL_MASTER_DATA.pack(self.channel, self.action, self.peer) 
136