311 lines
11 KiB
Python
Executable file
311 lines
11 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# main.py
|
|
#
|
|
# Copyright 2014 Fanir <projects@mail.fanir.de>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
# MA 02110-1301, USA.
|
|
#
|
|
#
|
|
|
|
|
|
# SETTINGS CAN BE FOUND AT THE BOTTOM OF THE FILE
|
|
|
|
|
|
import sys, time, string, socket, re, signal
|
|
from select import poll, POLLIN, POLLPRI, POLLOUT,\
|
|
POLLERR, POLLHUP, POLLNVAL
|
|
from threading import Thread#, Event
|
|
|
|
bot = None
|
|
|
|
class log():
|
|
DEBUG, INFO, WARNING, ERROR, FATAL, SILENT =\
|
|
0, 1, 2, 3, 4, 5
|
|
|
|
def show(level, msg):
|
|
if level in range(log.DEBUG, log.SILENT):
|
|
if LOGLEVEL <= level: print(msg)
|
|
else:
|
|
raise ValueError("That's not a loglevel!")
|
|
|
|
|
|
class pircbot():
|
|
def encode(self, textstring):
|
|
for codec in self.encodings:
|
|
try: return textstring.encode(codec)
|
|
except UnicodeDecodeError: continue
|
|
return textstring.encode(self.encodings[0], 'ignore')
|
|
|
|
def decode(self, textstring):
|
|
for codec in self.encodings:
|
|
try: return textstring.decode(codec)
|
|
except UnicodeDecodeError: continue
|
|
return textstring.decode(self.encodings[0], 'ignore')
|
|
|
|
def __init__(self, nicknames, server, port=6667, ident="pircbot",
|
|
realname="pircbot", encodings=("utf-8", "latin-1"),
|
|
command_prefix=".", admins=""):
|
|
self.nicknames = nicknames
|
|
self.server = server
|
|
self.port = port
|
|
self.ident = ident
|
|
self.realname = realname
|
|
self.encodings = encodings
|
|
self.admins = admins
|
|
self.cmdprefix = command_prefix
|
|
self.socket = None
|
|
self.recvloop = None
|
|
self.recvbuffer = bytearray(1024)
|
|
self.run = False
|
|
self.ready = False
|
|
self.is_alive = False
|
|
self.need_nick = True
|
|
|
|
def recv(self):
|
|
"""
|
|
Loop for reciving data
|
|
"""
|
|
parser = Thread(target=self.parse, name="parser")
|
|
p = poll()
|
|
p.register(self.socket.fileno(), POLLIN)
|
|
while self.run:
|
|
ap = p.poll(1000)
|
|
if (self.socket.fileno(), POLLIN) in ap:
|
|
self.recvbuffer.extend(self.socket.recv(1024))
|
|
if not parser.is_alive():
|
|
parser = Thread(target=self.parse, name="parser")
|
|
parser.start()
|
|
if parser.is_alive(): parser.join()
|
|
|
|
def connect(self):
|
|
# connect
|
|
self.socket = socket.socket()
|
|
try:
|
|
self.socket.connect((self.server, self.port))
|
|
except socket.error as e:
|
|
log.show(log.FATAL, "Fehler: %s" % e)
|
|
return
|
|
|
|
self.run = True
|
|
|
|
# start getting data
|
|
self.recvloop = Thread(target=self.recv, name="recvloop")
|
|
self.recvloop.start()
|
|
|
|
# get a nick
|
|
self.socket.send(self.encode("NICK %s\r\n" % self.nicknames.pop(0)))
|
|
|
|
self.socket.send(self.encode("USER %s %s bla :%s\r\n" % (self.ident, self.server, self.realname)))
|
|
|
|
self.is_alive = True
|
|
|
|
def parse(self):
|
|
"""
|
|
Loop for parsing incoming data
|
|
"""
|
|
#line = ""
|
|
origin = {}
|
|
while self.run and self.recvbuffer != b"":
|
|
# get and decode line from buffer
|
|
rawline, _, self.recvbuffer = self.recvbuffer.partition(b"\r\n")
|
|
rawline = self.decode(rawline)
|
|
# prepare line
|
|
line = rawline.split(" :", 1)
|
|
head = line[0].lstrip("\x00").split(" ")
|
|
larg = line[1] if len(line)>1 else ""
|
|
# parse prefix
|
|
if head[0].startswith(":"):
|
|
prefix = head.pop(0)[1:]
|
|
origin.clear()
|
|
if "@" in prefix:
|
|
origin["nick"], origin["ident"], origin["host"] = re.match(r"(\S+)!(\S+)@(\S+)", prefix).groups()
|
|
else:
|
|
origin["server"] = prefix
|
|
else:
|
|
prefix = ""
|
|
# parse command
|
|
command = head.pop(0)
|
|
# parse params
|
|
params = head
|
|
params.append(larg)
|
|
|
|
log.show(log.DEBUG, ">> %s" % rawline)
|
|
|
|
if command == "PING":
|
|
self.socket.send(self.encode("PONG %s\r\n" % params[0]))
|
|
elif command == "PRIVMSG":
|
|
if params[1].startswith(self.cmdprefix):
|
|
args = params[1].lstrip(self.cmdprefix).split(" ")
|
|
sndline = self.on_command(prefix, origin, params[0], args[0], args[1:])
|
|
if sndline != None:
|
|
log.show(log.DEBUG, "<< %s" % sndline)
|
|
self.socket.send(self.encode(sndline))
|
|
elif command == "001":
|
|
self.ready = True
|
|
elif command == "433":
|
|
self.socket.send(self.encode("NICK %s\r\n" % self.nicknames.pop(0)))
|
|
elif command == "KILL":
|
|
print("Got killed: %s", rawline)
|
|
self.die()
|
|
|
|
def is_admin(self, user):
|
|
for admin in self.admins:
|
|
if re.search(admin, user) != None:
|
|
return True
|
|
return False
|
|
|
|
def die(self):
|
|
self.run = False
|
|
self.recvloop.join()
|
|
self.is_alive = False
|
|
sys.exit()
|
|
|
|
def quit(self, reason=""):
|
|
self.socket.send(self.encode("QUIT :%s\n" % reason))
|
|
self.run = False
|
|
self.recvloop.join()
|
|
self.is_alive = False
|
|
|
|
def join(self, channel):
|
|
print(channel)
|
|
self.socket.send(self.encode("JOIN %s\n" % channel))
|
|
|
|
def part(self, channel):
|
|
self.socket.send(self.encode("PART %s\n" % channel))
|
|
|
|
def on_command(self, prefix, origin, source, command, params):
|
|
"""
|
|
Executed when getting a PRIVMSG starting with self.cmdprefix
|
|
Prefix contains the optional prefix of the raw line.
|
|
Origin is a map holding the parsed prefix, containing
|
|
"nick", "ident" and "host" for users and "server" for servers.
|
|
Source is the first parameter after the irc-command, specifying
|
|
the channel or user, from where the line comes.
|
|
Command is the command for the bot.
|
|
Params contains a list of originally space separated parameters.
|
|
"""
|
|
print(params)
|
|
if command.startswith("hello"):
|
|
greeting = "".join(("Hi " + origin["nick"] +"!"))
|
|
if source[0] in {"#", "+", "!", "&"}:
|
|
return "PRIVMSG %s :%s\r\n" % (source, greeting)
|
|
else:
|
|
return "PRIVMSG %s :%s\r\n" % (origin["nick"], greeting)
|
|
elif command.startswith("join") and len(params)>0:
|
|
if self.is_admin(origin["nick"]): self.join(params[0])
|
|
else: return "PRIVMSG %s :You can't do that!\r\n" % origin["nick"]
|
|
elif command.startswith("part") and len(params)>0:
|
|
if self.is_admin(origin["nick"]): self.part(params[0])
|
|
else: return "PRIVMSG %s :You can't do that!\r\n" % origin["nick"]
|
|
|
|
|
|
def parseargs():
|
|
import argparse
|
|
p = argparse.ArgumentParser(
|
|
description = "i think my desc is missing")
|
|
p.add_argument("action", default="help", choices = ["start", "stop"], help="What to do?")
|
|
#p.add_argument("--daemon", "-d", type = bool, choices = [1, 0], default=1, help="Daemonize, Default: 1")
|
|
return p.parse_args()
|
|
|
|
def KeyboardInterruptHandler(signum, frame):
|
|
global bot
|
|
print("Got Ctrl-C, dying now...")
|
|
bot.quit("")
|
|
sys.exit()
|
|
|
|
def main():
|
|
global bot
|
|
signal.signal(signal.SIGINT, KeyboardInterruptHandler)
|
|
|
|
args = parseargs()
|
|
if args.action == "start":
|
|
bot = pircbot(nicknames=NICKNAMES, ident=IDENT, realname=REALNAME,
|
|
server=SERVER, port=PORT, encodings=ENCODINGS, command_prefix=COMMAND_PREFIX, admins=ADMINS)
|
|
try:
|
|
bot.connect()
|
|
while bot.ready == False: time.sleep(1)
|
|
for channel in CHANNELS:
|
|
bot.join(channel)
|
|
while 1:
|
|
if bot.is_alive == False: print("X")
|
|
time.sleep(10)
|
|
except SystemExit:
|
|
print("exiting...")
|
|
elif args.action == "stop": print("nope!")
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
################
|
|
### SETTINGS ###
|
|
################
|
|
|
|
# With how much information do you want to be annoyed?
|
|
# DEBUG spams most, FATAL least. WARNING should be a good tradeoff.
|
|
# One of: log.DEBUG, log.INFO, log.WARNING, log.ERROR, log.FATAL
|
|
LOGLEVEL = log.DEBUG
|
|
|
|
|
|
# Also known as username. Some IRC-internal.
|
|
# By default, the nickname will be used as ident.
|
|
IDENT = "chalkbot"
|
|
|
|
# The list of nicknames to try. If the first one is not aviable, it will
|
|
# try the second, and so on...
|
|
# You should specfy at least two nicks.
|
|
NICKNAMES = ["chalkbot", "chalkbot_", "chalkbot__"]
|
|
|
|
REALNAME = "A ChalkBot Instance"
|
|
|
|
# Command for registering with nickserv, without leading slash.
|
|
NICKSERVCMD = ""
|
|
|
|
MODES = "+B"
|
|
|
|
|
|
# The Server name to connect to. Duh!
|
|
#SERVER = "fanir.de"
|
|
SERVER = "localhost"
|
|
|
|
# "Default" is 6667. An often used port for SSL would be 6697, if SSL would be
|
|
# supported. Maybe in a future, far far away...
|
|
PORT = 6667
|
|
|
|
# A comma-seperated list of channels to join, enclosed by braces.
|
|
CHANNELS = ["#bots", "#main"]
|
|
|
|
# The encodings to try when getting messages from IRC. Will be tried in the given order.
|
|
# The first one is used to encode data when sending stuff.
|
|
# The list given shoud do just fine in most networks, I assume.
|
|
# Also comma seperated and enclosed by braces.
|
|
ENCODINGS = ['utf-8', 'latin-1', 'iso-8859-1', 'cp1252']
|
|
|
|
|
|
# List of users (hostmasks, will be parsed as regex) who can do important stuff,
|
|
# like joining and parting channels and shutting down the bot.
|
|
ADMINS = ["Fanir.*"]
|
|
|
|
COMMAND_PREFIX = "."
|
|
|
|
#######################
|
|
### END OF SETTINGS ###
|
|
#######################
|
|
|
|
|
|
main()
|