def pkt_part(self, event): """ Received a part packet. Similar to ``pkt_join``. This method determines whether or not the client is being kicked off the server. """ if event.arguments['ns'] in self.channel.keys(): del self.channel[event.arguments['ns']] if len(self.channel) > 0: return if 'r' in event.arguments: if event.arguments['r'] in ('bad data', 'bad msg', 'msg too big' ) or 'killed:' in event.arguments['r']: self.handle_pkt( Packet('disconnect{0}e={1}{2}{3}'.format( "\n", event.arguments['r'], "\n", "\n")), time.time()) return if event.arguments['e'] != 'ok': return if self.channel or self.flag.disconnecting or self.flag.quitting: return self.handle_pkt(Packet('disconnect\ne=no joined channels\n\n'), time.time())
def process_property(self, data): """ Called when receive a property packet for the channel. This method makes sure that the data is stored in the right places in the object. """ if data.arguments['p'] == 'title': self.title.content = data.arguments['value'] self.title.by = data.arguments['by'] self.title.ts = data.arguments['ts'] if data.arguments['p'] == 'topic': self.topic.content = data.arguments['value'] self.topic.by = data.arguments['by'] self.topic.ts = data.arguments['ts'] if data.arguments['p'] == 'privclasses': self.pc = Packet(data.arguments['value'], ':').args self.pc_order = sorted(self.pc.keys(), key=int) self.pc_order.reverse() if data.arguments['p'] == 'members': member = Packet(data.arguments['value']) while member.cmd != None and len(member.args) > 0: self.register_user(member) member = Packet(member.body)
def dataReceived(self, data): """ Called by twisted when data is received. The data received is added to out buffer. If there are any full packets in the buffer, these packets are sent to the :py:class:`ChatClient <dAmnViper.base.ChatClient>` instance to be parsed properly. Any event handling relating to specific packets is done in the ``ChatClient`` instance. """ # Tell the client some data has arrived. Woo... self.client.dataReceived(data) # Split on null. self.__buffer += data raw = self.__buffer.split('\0') self.__buffer = raw.pop() for chunk in raw: packet = Packet(chunk) # If it's a ping packet, send a pong straight away! if packet.cmd == 'ping': self.send_packet('pong\n') # Let the client do whatever it needs to with the packet. self.client.handle_pkt(packet, time.time())
def pkt_recv_join(self, event): """ Received a recv_join packet. This happens when a user joins a channel in which the client is also present. This method simply stores information about the user that just joined. """ self.channel[event.arguments['ns']].register_user( Packet(event.arguments['info']), event.arguments['user'])
def pkt_kicked(self, event): """ Received a kicked packet. This happens when the client is kicked from a channel. Here we automatically rejoin the channel if we are permitted to do so. """ del self.channel[event.arguments['ns']] if self.flag.disconnecting or self.flag.quitting: return if 'r' in event.arguments: if 'autokicked' in event.arguments['r'].lower( ) or 'not privileged' in event.arguments['r'].lower(): if len(self.channel) > 0: return self.handle_pkt(Packet('disconnect\ne=no joined channels\n\n'), time.time()) return if self.flag.autorejoin: self.join(event.arguments['ns'])
def pkt_join(self, event): """ Received a join packet. This is sent by the server when the client tries to join a channel on the server. If the join was successful, a :py:class:`Channel object <dAmnViper.data.Channel>` is created for the channel and stored in the ``channel`` attribute of the client. If the join failed, the client disconnects if there are no other joined channels. (``naive``) """ if event.arguments['e'] == 'ok': ns = event.arguments['ns'] self.channel[ns] = Channel(ns, self.deform_ns(ns)) return if len(self.channel) > 0: return self.handle_pkt(Packet('disconnect\ne=no joined channels\n\n'), time.time())