lacewing.packetloaders.server

1 from struct import Struct 2 3 from lacewing.baseloader import _BaseLoader, _EmptyLoader 4 from lacewing.bitdict import BitDict 5 from lacewing.packetloaders.common import (CONNECT, SET_NAME, JOIN_CHANNEL, 6 LEAVE_CHANNEL, CHANNEL_LIST) 7 from lacewing.packetloaders.common import (_BinaryMessageMixin, 8 _ObjectMessageMixin) 9 10 RESPONSE_DATA = Struct('<BB') 11 NAME_DATA = Struct('<B') 12 SUBCHANNEL_DATA = Struct('<B') 13 JOIN_CHANNEL_DATA = Struct('<BB') 14 CHANNEL_ID = Struct('<H') 15 YOUR_ID = Struct('<H') 16 PEER_DATA = Struct('<HBB') 17 CHANNEL_LIST_DATA = Struct('<HB') 18 CHANNEL_MESSAGE_DATA = Struct('<BH') 19 PEER_MESSAGE_DATA = Struct('<BHH') 20 NEW_PEER_DATA = Struct('<HHB') 21 PEER_LEAVE_DATA = Struct('<HH') 22

23 -class ChannelPeer(_BaseLoader):

24 id = None 25 isMaster = None 26 name = None 27

28 - def read(self, data):

29 self.id, flags, size = PEER_DATA.unpack_from(data) 30 self.isMaster = flags 31 self.name = str(buffer(data, PEER_DATA.size, size)) 32 return PEER_DATA.size + size

33

34 - def generate(self):

35 return PEER_DATA.pack(self.id, int(self.isMaster), 36 len(self.name)) + self.name

37

38 -class Response(_BaseLoader):

39 response = None 40 success = None 41 welcome = None 42 name = None 43 isMaster = None 44 channel = None 45 peers = None 46 channels = None 47 playerId = None 48 value = None 49

50 - def read(self, data):

51 self.response, self.success = RESPONSE_DATA.unpack_from(data) 52 data = buffer(data, 2) 53 if self.response == CONNECT and self.success: 54 self.playerId, = YOUR_ID.unpack_from(data) 55 self.welcome = str(buffer(data, 2)) 56 elif self.response == SET_NAME: 57 size, = NAME_DATA.unpack_from(data) 58 self.name = str(buffer(data, 1, size)) 59 data = buffer(data, 1 + size) 60 elif self.response == JOIN_CHANNEL: 61 self.isMaster, size = JOIN_CHANNEL_DATA.unpack_from(data) 62 self.name = str(buffer(data, JOIN_CHANNEL_DATA.size, size)) 63 data = buffer(data, JOIN_CHANNEL_DATA.size + size) 64 if self.success: 65 self.channel, = CHANNEL_ID.unpack_from(data) 66 data = buffer(data, 2) 67 self.peers = peers = [] 68 while data: 69 peer = ChannelPeer() 70 peers.append(peer) 71 bytesRead = peer.read(data) 72 data = buffer(data, bytesRead) 73 elif self.response == LEAVE_CHANNEL: 74 self.channel, = CHANNEL_ID.unpack_from(data) 75 data = buffer(data, 2) 76 elif self.response == CHANNEL_LIST and self.success: 77 self.channels = channels = [] 78 while data: 79 count, size = CHANNEL_LIST_DATA.unpack_from(data) 80 name = buffer(data, CHANNEL_LIST_DATA.size, size) 81 data = buffer(data, CHANNEL_LIST_DATA.size + size) 82 channels.append((name, count)) 83 if not self.success: 84 self.value = str(data)

85

86 - def addPeer(self, name, id, isMaster):

87 if self.peers is None: 88 self.peers = [] 89 peer = ChannelPeer() 90 peer.id = id 91 peer.isMaster = isMaster 92 peer.name = name 93 self.peers.append(peer)

94

95 - def generate(self):

96 data = RESPONSE_DATA.pack(self.response, self.success) 97 if self.response == CONNECT: 98 data += YOUR_ID.pack(self.playerId) 99 data += self.welcome or '' 100 elif self.response == SET_NAME: 101 data += NAME_DATA.pack(len(self.name)) + self.name 102 elif self.response == JOIN_CHANNEL: 103 data += JOIN_CHANNEL_DATA.pack( 104 int(self.isMaster or 0), len(self.name)) + self.name 105 if self.success: 106 data += CHANNEL_ID.pack(self.channel) 107 for item in self.peers or (): 108 data += item.generate() 109 elif self.response == LEAVE_CHANNEL: 110 data += CHANNEL_ID.pack(self.channel) 111 elif self.response == CHANNEL_LIST and self.success: 112 for (name, count) in self.channels: 113 data += CHANNEL_LIST_DATA.pack(count, len(name)) + name 114 if not self.success: 115 data += self.value or '' 116 return data

117

118 -class _ServerMessage(_BaseLoader):

119 subchannel = None

120 - def read(self, data):

121 self.subchannel, = SUBCHANNEL_DATA.unpack_from(data) 122 self.readMessage(buffer(data, 1))

123

124 - def generate(self):

125 return SUBCHANNEL_DATA.pack(self.subchannel) + self.generateMessage()

126

127 -class _PeerMessage(_BaseLoader):

128 subchannel = None 129 channel = None 130 peer = None

131 - def read(self, data):

132 (self.subchannel, self.channel, 133 self.peer) = PEER_MESSAGE_DATA.unpack_from(data) 134 self.readMessage(buffer(data, PEER_MESSAGE_DATA.size))

135

136 - def generate(self):

137 return PEER_MESSAGE_DATA.pack(self.subchannel, 138 self.channel, self.peer) + self.generateMessage()

139

140 -class BinaryServerMessage(_BinaryMessageMixin, _ServerMessage):

141 pass

142

143 -class BinaryChannelMessage(_BinaryMessageMixin, _PeerMessage):

144 pass

145

146 -class BinaryPeerMessage(_BinaryMessageMixin, _PeerMessage):

147 pass

148

149 -class ObjectServerMessage(_ObjectMessageMixin, _ServerMessage):

150 pass

151

152 -class ObjectChannelMessage(_ObjectMessageMixin, _PeerMessage):

153 pass

154

155 -class ObjectPeerMessage(_ObjectMessageMixin, _PeerMessage):

156 pass

157

158 -class Peer(_BaseLoader):

159 channel = None 160 peer = None 161 isMaster = None 162 name = None 163

164 - def read(self, data):

165 if len(data) == PEER_LEAVE_DATA.size: 166 self.channel, self.peer = PEER_LEAVE_DATA.unpack_from(data) 167 else: 168 self.channel, self.peer, self.isMaster = NEW_PEER_DATA.unpack_from( 169 data) 170 self.name = str(buffer(data, NEW_PEER_DATA.size))

171

172 - def generate(self):

173 if self.isMaster is None and self.name is None: 174 return PEER_LEAVE_DATA.pack(self.channel, self.peer) 175 else: 176 return NEW_PEER_DATA.pack(self.channel, self.peer, 177 self.isMaster) + self.name

178

179 -class UDPWelcome(_EmptyLoader):

180 pass

181

182 -class Ping(_EmptyLoader):

183 pass

184

Source Code for Module lacewing.packetloaders.server