def __init__(self, ip, port, nick, user, password, *chan_list):
""" It sets up the bot instance. """
sock = socket(AF_INET, SOCK_STREAM)
# We have to wrap our socket with a SuperSocket instance
# in order to have our events issued when data comes
# from the socket.
con = SuperSocket(sock)
# This protocol is required by uxirc.irc protocol.
# It spawns CONNECT.
Client(con)
# We use connect_ex since we do not want an exception.
# Untwisted uses non blocking sockets.
con.connect_ex((ip, port))
# We save whatever we might need.
self.nick = nick
self.user = user
self.password = password
self.chan_list = chan_list
self.ip = ip
self.port = port
# It maps CONNECT to self.send_auth so
# when our socket connects it sends NICK and USER info.
con.add_map(CONNECT, self.send_auth)
con.add_map(CONNECT_ERR, lambda con, err: lose(con))
def on_connect(self, con):
area = self.create_area(self.addr)
area.bind('<Destroy>',
lambda event: send_cmd(con, 'QUIT :vy rules!'),
add=True)
SockWriter(con)
SockReader(con)
Terminator(con)
Irc(con)
self.misc = Misc(con)
con.add_map(CLOSE, lambda con, err: lose(con))
con.add_map('*JOIN', self.create_channel)
con.add_map(
Terminator.FOUND,
lambda con, data: area.append('%s\n' % data.decode(self.encoding)))
con.add_map('PMSG', self.e_pmsg)
con.add_map('376', lambda con, *args: send_cmd(con, self.irccmd))
con.add_map('376', self.auto_join)
con.add_map(
'PING',
lambda con, prefix, servaddr: send_cmd(con, 'PONG :%s' % servaddr))
send_cmd(con, 'NICK %s' % self.nick)
send_cmd(con, 'USER %s' % self.user)
def on_connect(self, ssock):
"""
"""
SockReader(ssock)
SockWriter(ssock)
ssock.add_map(LOAD, self.on_load)
ssock.add_map(CLOSE, lambda con, err: lose(con))
def on_accept(self, local, ssock):
"""
"""
SockReader(ssock)
SockWriter(ssock)
Fixed(ssock)
ssock.dumpfile(self.fd)
ssock.add_map(CLOSE, lambda con, err: lose(con))
ssock.add_map(Fixed.FOUND, self.on_ack)
ssock.add_handle(
lambda ssock, event, args: self.drive(event, ssock, *args))
self.timer.cancel()
def __init__(self, host, port, fd, size):
"""
"""
Dispatcher.__init__(self)
sock = socket(AF_INET, SOCK_STREAM)
ssock = SuperSocket(sock)
self.port = port
self.fd = fd
self.size = size
Client(ssock)
ssock.connect_ex((host, port))
ssock.add_map(CONNECT, self.on_connect)
ssock.add_map(CONNECT_ERR, lambda con, err: lose(con))
ssock.add_handle(
lambda ssock, event, args: self.drive(event, ssock, *args))
def send_auth(con, nick, user, cmd, delay):
SockWriter(con)
SockReader(con)
Terminator(con)
Irc(con)
logcon(con)
def do_job(ssock, *args):
for ind in cmd:
send_cmd(ssock, ind)
sleep(delay)
con.add_map('376', do_job)
con.add_map(
'PING',
lambda con, prefix, servaddr: send_cmd(con, 'PONG :%s' % servaddr))
con.add_map(CLOSE, lambda con, err: lose(con))
send_cmd(con, 'NICK %s' % nick)
send_cmd(con, 'USER %s' % user)
def setup(con):
SockWriter(con)
SockReader(con)
Terminator(con)
Irc(con)
CTCP(con)
con.add_map(
'PING',
lambda con, prefix, servaddr: send_cmd(con, 'PONG :%s' % servaddr))
con.add_map('376', lambda con, *args: send_cmd(con, 'JOIN #ameliabot'))
con.add_map('PRIVMSG', send_file)
con.add_map('DCC SEND', check_file_existence)
con.add_map('376', get_myaddr)
con.add_map(CLOSE, lambda con, err: lose(con))
logcon(con)
send_cmd(con, 'NICK %s' % NICK)
send_cmd(con, 'USER %s' % USER)
def send_auth(self, con):
# It is what we use to send data. send_msg function uses
# ssock.dump function to dump commands.
SockWriter(con)
SockReader(con)
# This protocol spawns FOUND whenever it finds \r\n.
Terminator(con)
Irc(con)
con.add_map(CLOSE, lambda con, err: lose(con))
# Now, it basically means: when it '376' irc command is
# issued by the server then calls self.auto_join.
# We use auto_join to send the sequence of JOIN
# commands in order to join channels.
con.add_map('376', self.auto_join)
# Below the remaining stuff follows the same pattern.
con.add_map('JOIN', self.on_join)
con.add_map('PING', self.on_ping)
con.add_map('PART', self.on_part)
con.add_map('376', self.on_376)
con.add_map('NOTICE', self.on_notice)
con.add_map('PRIVMSG', self.on_privmsg)
con.add_map('332', self.on_332)
con.add_map('001', self.on_001)
con.add_map('001', self.on_002)
con.add_map('003', self.on_003)
con.add_map('004', self.on_004)
con.add_map('333', self.on_333)
con.add_map('353', self.on_353)
con.add_map('366', self.on_366)
con.add_map('474', self.on_474)
con.add_map('302', self.on_302)
send_cmd(con, 'NICK %s' % self.nick)
send_cmd(con, 'USER %s' % self.user)
send_msg(con, 'nickserv', 'identify %s' % self.password)
def handle_accept(self, server, con):
SockWriter(con)
SockReader(con)
con.dump(('%s\r\n' % asctime()).encode('utf-8'))
con.add_map(CLOSE, lambda con, err: lose(con))
def handle_bdata(self, con, fd, data):
lose(con)
self.handle_response()
def terminate(self):
lose(self.ssock)
lose(self.server)
die()
def handle_connect(self, client):
print('Connected!', client)
lose(client)
lose(self.server)
die()
def handle_done(self, client, data):
print('Received bytes from:', self.client)
lose(client)
lose(self.server)
die()
def handle_done(self, client, a, b):
self.assertEqual(a, b'abc' * 100)
self.assertEqual(b, b'efg' * 100)
lose(client)
lose(self.server)
die()
def handle_accept(self, server, ssock):
print('Accepted:', ssock)
lose(ssock)
lose(self.server)
die()
def handle_done(self, ssock, data):
print('Received bytes from:', ssock)
lose(ssock)
lose(self.server)
die()
def handle_connect(self, client):
lose(client)
lose(self.server)
def setup(server, con):
SockReader(con)
SockWriter(con)
con.add_map(CLOSE, lambda con, err: lose(con))
con.add_map(LOAD, lambda con, data: sys.stdout.write('%s\r\n' % data))
def run_done(self, ssock):
lose(ssock)
self.sdrive(DONE)
def run_done(self, ssock):
lose(ssock)
lose(self.local)
ssock.drive(DONE)
def on_timeout(self):
self.drive(TIMEOUT)
lose(self.local)
