def main():
#Initialize IRC Objects
#Global for access by other classes.
global irc
global server
global con
global accessHosts
global clientList
accessHosts = list()
accessHosts.append(config.owners)
clientList = list()
irc = irclib.IRC()
server = irc.server()
#Reload the config file to implement changes.
reload(config)
#Set up sqlite tables and databases
try:
con = lite.connect('popm.db')
cur = con.cursor()
cur.execute(
"CREATE TABLE IF NOT EXISTS ipcache(ip TEXT, time INT, lastResult INT)"
)
cur.execute(
"CREATE TABLE IF NOT EXISTS stats(lookups INT, banned INT, bannedsinceconnect INT, connecttime INT)"
)
con.commit()
con.close()
except lite.Error, e:
p_debug('Error from SQLite: %s' % (e.args[0]))
con.rollback()
con.close()
def handle(self, *args, **options):
if len(args) != 2: raise CommandError('usage: ircbot server channel')
server = args[0]
channel = args[1]
if channel[0] != '#': channel = '#' + channel
msg_thread = threading.Thread(target=watch_messages, args=(args[1], ))
msg_thread.daemon = True
msg_thread.start()
irc = irclib.IRC()
server = irc.server()
server.connect(server, 6667, 'CollabSrcBot', ircname='CollabSrcBot')
server.join(channel)
global instance
instance = server
# make sure we don't flood the channel with old messages
msglist = AdminMessage.objects.filter(
Q(to__contains='ircbot') | Q(to__contains='any')).exclude(
handled_by__contains='ircbot').order_by('-event_time')
for msg in msglist:
msg.handled_by += 'ircbot'
msglist.update()
irc.process_forever()
def main():
botname = None
voiceword = None
ircserver = None
broadcastchan = None
try:
cfg = Conf.get('voicebot')
botname = cfg.get('name')
voiceword = cfg.get('voiceword')
ircserver = Conf.get('ircserver')
broadcastchan = Conf.get('broadcastchan')
except:
print "Error: Bad Configuration!"
print ""
print "You need a voicebot section with a name and voiceword configured"
print "Also, ircserver and broadcastchan are needed"
return 1
print "Voicebot is starting.."
irc = irclib.IRC()
irc.add_global_handler(
"pubmsg", lambda c, e: voiceThem(broadcastchan, voiceword, c, e), -20)
server = irc.server()
server.connect(ircserver[0], ircserver[1], botname)
server.join(broadcastchan)
print "Connected, joining eventloop."
irc.process_forever()
def __init__(self, *args, **kwargs):
"""IrcBot constructor.
@param conffile: name of configuration file
@type conffile: string
"""
self.config = dhm.nestdict.NestedDict(
dhm.config.Parse(kwargs["config"]))
self.logger = logging.getLogger("ircbot")
self.irc = irclib.IRC()
self.server = self.irc.server()
self.logger.info("Connecting to irc server " +
self.config["IRC/server"])
self.connection = self.server.connect(self.config["IRC/server"],
self.config["IRC/port"],
self.config["IRC/nick"],
username=self.config["IRC/name"])
self.logger.info("Trying to join channel " +
self.config["IRC/channel"])
if self.config.has_key("IRC/password"):
self.server.join(self.config["IRC/channel"],
self.config["IRC/password"])
else:
self.server.join(self.config["IRC/channel"])
for i in filter(lambda x: x.startswith("On"), dir(self)):
self.connection.add_global_handler(i[2:].lower(), getattr(self, i))
def _setupIrc(self):
ircnick = self.nickPrefix + self.dev.getMac().replace(":", "")
self.irc = irclib.IRC()
self.irc.add_global_handler("privmsg", lambda c, e: self.sendToDevIrcCallback(False, c, e), -20)
self.irc.add_global_handler("pubmsg", lambda c, e: self.sendToDevIrcCallback(True, c, e), -20)
self.irc.add_global_handler("privnotice", self.printNotice, -20)
self.server = self.irc.server()
self.server.connect(self.ircserver[0], self.ircserver[1], ircnick)
self.server.join(self.broadcastchan)
if self.voiceWord:
self.irclog.info("Sending voiceword to %s" % self.broadcastchan)
self.server.privmsg(self.broadcastchan, self.voiceWord)
# add sockets
self.readSockets = map(lambda x: x._get_socket(), self.irc.connections)
self.readSockets = filter(lambda x: x != None, self.readSockets)
# execute post connect command
if self.postConnectCmd:
cmd = self.postConnectCmd
if cmd.find("%s") >= 0:
print cmd
cmd = cmd % (self.dev.getName(),)
subprocess.Popen(cmd, shell=True)
def run(self):
self.conf = {
'network': None,
'port': None,
'nick': None,
'username': None,
'ircname': None,
'channel': None,
'debug': None
}
self.config = ConfigParser.RawConfigParser()
self.config.read(self.file)
for key in self.conf.keys():
self.conf[key] = self.config.get('irc_bot', key)
try:
#irclib.DEBUG = conf['debug']
irc = irclib.IRC()
server = irc.server()
server.connect(self.conf['network'], int(self.conf['port']), self.conf['nick'], username = self.conf['username'], ircname = self.conf['ircname'] )
server.join(self.conf['channel'])
irc.add_global_handler('join', self.handleJoin)
irc.add_global_handler('part', self.handlePart)
irc.add_global_handler('quit', self.handleQuit)
except Exception, ex:
print "Xi cagou: %s" % ex
sys.exit(1)
def __init__(self, base):
super(IRCProtocol, self).__init__(base, scheme=COLOR_SCHEME)
if settings.IRC_DEBUG:
irclib.DEBUG = 1
else:
irclib.DEBUG = 0
self.irc = irclib.IRC()
self.server = self.irc.server()
for event in self.events:
self.log.info(u'[IRC] * Registering event: %s' % event)
self.server.add_global_handler(event, getattr(self, u'on_' + event), 0)
self.channels = settings.IRC_CHANNELS
self.names = {}
self.last_names_update = unix_time()
# throttling
self.delay = settings.IRC_DELAY_LINES / float(1000)
self.last_response = 0.0
# keepalive
self.keepalive = settings.IRC_KEEPALIVE
if self.keepalive:
self.last_keepalive = self.last_pong = unix_time()
self.keepalive_freq = settings.IRC_KEEPALIVE_FREQ
self.keepalive_timeout = settings.IRC_KEEPALIVE_TIMEOUT
def __init__(self, configFilename):
self.configFilename = configFilename
self.config = load_config(self.configFilename)
global ACTIVE_PREFIXES
ACTIVE_PREFIXES = PREFIXES[self.config.get('irc', 'prefixes')]
oauth_file = self.config.get('twitter', 'oauth_token_file')
if not os.path.exists(oauth_file):
oauth_dance("IRC Bot", CONSUMER_KEY, CONSUMER_SECRET, oauth_file)
oauth_token, oauth_secret = read_token_file(oauth_file)
self.twitter = Twitter(auth=OAuth(oauth_token, oauth_secret,
CONSUMER_KEY, CONSUMER_SECRET),
domain='api.twitter.com')
self.irc = irclib.IRC()
self.irc.add_global_handler('privmsg', self.handle_privmsg)
self.irc.add_global_handler('ctcp', self.handle_ctcp)
self.irc.add_global_handler('umode', self.handle_umode)
self.ircServer = self.irc.server()
self.sched = Scheduler(
(SchedTask(self.process_events,
1), SchedTask(self.check_statuses, 120)))
self.lastUpdate = (datetime.utcnow() -
timedelta(minutes=10)).utctimetuple()
def __init__(self, linelen=32):
"""Constructor."""
threading.Thread.__init__(self)
self.running = False
self._curpace = 0.1
self.il = None
try:
import irclib
self.ih = irclib.IRC()
self.il = irclib
except ImportError:
self.ih = fakeirc()
self.ic = self.ih.server()
self.np = tod.tod('now')+tod.tod('30') # self ping timeeout
self.name = 'uSCBsrv'
self.rdbuf = ''
self.wrbuf = ''
self.chanstatus = False
self.host = USCBSRV_HOST
self.port = USCBSRV_PORT
self.channel = USCBSRV_CHANNEL
self.srvnick = USCBSRV_SRVNICK
self.doreconnect = False
self.connect_pending = False
self.dumbcnt = 0
self.curov = None
self.linelen = linelen
self.queue = Queue.Queue()
self.log = logging.getLogger('scbdo.uscbsrv')
self.log.setLevel(logging.DEBUG)
def __init__(self,
jid,
password,
nickname,
admins=[],
error_fd=sys.stderr,
debug=False):
threading.Thread.__init__(self)
self.halt = False
self.bridges = []
self.bare_jid = xmpp.protocol.JID(jid=jid)
self.bare_jid.setResource('')
self.nickname = nickname
self.password = password
self.error_fd = error_fd
self.debug = debug
self.admins = admins
self.xmpp_connections = {}
self.irc = irclib.IRC()
self.irc.bot = self
self.irc.add_global_handler('all_events', self._irc_event_handler)
self.irc_thread = threading.Thread(target=self.irc.process_forever)
self.irc_thread.start()
# Open connection with XMPP server
try:
self.xmpp_c = self.get_xmpp_connection(self.nickname)
except:
self.error(say_levels.error, 'XMPP Connection failed')
raise
self.xmpp_thread = threading.Thread(target=self._xmpp_loop)
self.xmpp_thread.start()
def __init__(self, conf):
'''Starts the irc client library and XMLRPC Server.'''
self.remote_irc_servers = {}
self.events = EventList()
# Makes sure files exist
#TODO: Reference documentation on how to generate these files.
if conf.cert_file and not os.path.exists(conf.cert_file):
raise RuntimeError('cert_file "%s" not found!' % conf.cert_file)
if conf.key_file and conf.key_file and not os.path.exists(conf.key_file):
raise RuntimeError('key_file "%s" not found!' % conf.key_file)
if not conf.accepted_certs_file:
certs_required = ssl.CERT_NONE
elif not os.path.exists(conf.accepted_certs_file):
raise RuntimeError('accepted_certs_file "%s" not found!' % conf.accepted_certs_file)
else:
certs_required = ssl.CERT_REQUIRED
self.irc_client = irclib.IRC()
self.irc_client.add_global_handler("all_events", self._handle_irc_event)
# Start xmlrpc server
self.xmlrpc_server = securexmlrpc.SecureXMLRPCServer(
(conf.bind_address, conf.bind_port),
certfile = conf.cert_file,
keyfile = conf.key_file,
ca_certs = conf.accepted_certs_file,
cert_reqs = certs_required,
)
self.xmlrpc_server.register_instance(self)
self.xmlrpc_server.timeout = 0.1 # Make handle_request() non-blocking
def __init__(self, db):
""" IRC objects constructor """
# MongoDB connection
self.db = db
# Create IRC object and connect to the network
self.irc = irclib.IRC()
self.server = self.irc.server()
self.server.connect(irc_server, irc_port, nickname)
# Join channels and send welcome message
for channel in channels_list:
self.server.join(channel)
self.sendmessage(channel, messages['che'])
# Register handlers
self.irc.add_global_handler('ping', self.ponger, -42)
self.irc.add_global_handler('privmsg', self.handlemessage)
self.irc.add_global_handler('pubmsg', self.handlemessage)
self.irc.add_global_handler('join', self.handlejoin)
# Reefunc instance
self.rf = reefuncs()
# Server connection checker
if self.server.is_connected():
self.feed_refresh()
# Go into an infinite loop
self.irc.process_forever()
def run(self):
irc = irclib.IRC()
for m in filter(lambda x: x.startswith('on_'), dir(self)):
irc.add_global_handler(m[3:], getattr(self, m))
c = irc.server()
self.connection = c
c.connect(self.server, 6667, self.nick)
while not self.die:
irc.process_once(0.2)
c.disconnect()
def irc_connect():
irc = irclib.IRC()
server = irc.server()
ircConn = server.connect(IRC_SERVER, IRC_PORT, IRC_NICK, ircname=IRC_NAME)
ircConn.join(IRC_CHANNEL)
ircConn.add_global_handler('privmsg', handle_privmsg, -1)
ircConn.add_global_handler('pubmsg', handle_pubmsg, -1)
ircConn.add_global_handler('join', handle_join, -1)
return irc, ircConn
def __init__(self):
self.start_time = time.time()
self.rules = []
self.already_done = deque([], maxlen=1000)
#initiate IRC connection
self.i = irclib.IRC()
self.load_irc_config()
def __init__(self, server, chan, key, nickname, local_port):
self.network = Network()
self.chan = chan
self.key = key
self.ircobj = irclib.IRC(self.add_socket, self.rm_socket)
self.connection = self.ircobj.server()
self.ircobj.add_global_handler("all_events", self._dispatcher, -10)
self.ircobj.add_global_handler("welcome", self.on_connect)
self.ircobj.add_global_handler("nicknameinuse", self.on_nicknameinuse)
self.connection.connect(server, 6667, nickname)
self.network.listen("127.0.0.1", local_port, self.read_message)
self.network.run_forever()
def __init__(self, gateway, irc_args):
self.nick = "atlas"
self.server, self.port, self.channel = irc_args
self.joined = []
self.gateway = gateway
self.irc = irclib.IRC()
self.connection = c = self.irc.server().connect(
self.server, self.port, self.nick, self.nick, self.nick)
c.add_global_handler("welcome", self.on_connect)
c.add_global_handler("join", self.on_join)
c.add_global_handler("disconnect", self.on_disconnect)
c.add_global_handler("pubmsg", self.on_pubmsg)
c.add_global_handler("namreply", self.existing_names)
def configure(self,
host="irc.freenode.net",
port=6667,
nick=None,
channels=["#rapidsms"]):
self.host = host
self.port = port
self.nick = self.config_requires(
"nick", nick)[:16] # 16 char limit for IRC nicks
self.channels = self.config_list(channels)
self.irc = irclib.IRC()
self.irc.add_global_handler("privmsg", self.privmsg)
self.irc.add_global_handler("pubmsg", self.pubmsg)
def __init__(self): self.connection = Connection() self.channels = set([])#['##tokyo-3'] self.nick = 'cslbot' self.name = 'tjcsl_bot' self.irc = irclib.IRC() self.addHandlers() self.server = self.irc.server() now = datetime.datetime.now() self.connection = "temporary" self.main_thread = threading.Thread(target=self.irc.process_forever) self.check_period = 2.0 self.checked = True self.timer = threading.Timer(self.check_period, self.process)
def __init__(self):
threading.Thread.__init__(self)
self.running = False
self.cb = None
self.ih = irclib.IRC()
self.ic = self.ih.server()
self.np = tod.tod('now')+tod.tod('30')
self.hasconnnected = False
self.rdbuf = ''
self.doreconnect = False
self.chanstatus = False
self.host = USCBSRV_HOST
self.port = USCBSRV_PORT
self.channel = USCBSRV_CHANNEL
self.cltnick = USCBSRV_CLTNICK
self.srvnick = USCBSRV_SRVNICK
self._curpace = 0.0
def setup(self, conn):
conn.in_extra = {}
if self.mode == 'TRANSPARENT':
pass
elif self.mode == 'HALF':
# could be in_extra, too, does not really matter
irc = irclib.IRC()
conn.out_extra = {}
conn.out_extra['irc'] = irc
conn.out_extra['irc_server'] = irc.server()
conn.in_extra['buffer'] = ""
# close this connection
conn.in_extra['close'] = False
elif self.mode == 'FULL':
conn.out_extra = {}
conn.in_extra['buffer'] = ""
# close this connection
conn.in_extra['close'] = False
irc = ircd(hashlib.md5(os.urandom(128)).hexdigest()[:16] + ".com")
# data coming from our server
conn.in_extra['irc_server'] = irc.server
# data coming from the client
conn.out_extra['irc_server'] = irc.client
def handle_action(connection, event):
nick = event.source().partition("!")[0]
msg = event.arguments()[0]
write_to_sign("* %s %s *" % (nick, msg))
def handle_join(connection, event):
nick = event.source().partition("!")[0]
write_to_sign("%s joined" % nick)
def handle_quit(connection, event):
nick = event.source().partition("!")[0]
msg = event.arguments()[0]
write_to_sign("%s quit [%s]" % (nick, msg))
if __name__ == '__main__':
irc = irclib.IRC()
irc.add_global_handler('pubmsg', handle_pubmsg)
irc.add_global_handler('join', handle_join)
irc.add_global_handler('quit', handle_quit)
irc.add_global_handler('action', handle_action)
server = irc.server()
server.connect("localhost", 6667, "signbot")
server.join("#test")
irc.process_forever()
def __init__(self, linelen=28):
"""Constructor."""
threading.Thread.__init__(self)
self.running = False
self.debug = False
self.il = None
self.localsrv = False
self.rdbuf = {} # source -> dest -> buf[]
self.pub_cb = None
self.iohandle = {}
self.addchans = set()
## HACK
self.linelen = linelen
self.pagelen = 7
self.encoding = 'utf-8'
self.log = logging.getLogger('telegraph')
self.log.setLevel(logging.DEBUG)
try:
import irclib
# CHECK: 16.2.9. "all import attempts must be completed
# before the interpreter starts shutting itself down."
self.ih = irclib.IRC(fn_to_add_socket=self._addsock,
fn_to_remove_socket=self._delsock)
self.il = irclib
except ImportError:
self.log.warn(u'irclib not present: Telegraph will not function.')
self.ih = fakeirc()
self.ic = self.ih.server()
self.ping_interval = PING_INTERVAL
self.np = tod.tod('now') + self.ping_interval
self.name = 'telegraph'
self.chanstatus = False
self.nick = TELEGRAPH_USER + unicode(random.randint(1000, 9999))
self.host = TELEGRAPH_HOST
self.port = TELEGRAPH_PORT
self.username = TELEGRAPH_USERNAME
self.fullname = TELEGRAPH_FULLNAME
self.channel = TELEGRAPH_CHANNEL
self.srvid = TELEGRAPH_FAKEHOST
self.privateservers = TELEGRAPH_PRIVATESERVERS
self.opername = TELEGRAPH_OPERNAME
self.operpass = TELEGRAPH_OPERPASS
self.doreconnect = False
self.connect_pending = False
self.dumbcnt = 0
self.curov = None # allow use as a sender
#self.linelen = linelen
self.queue = Queue.Queue()
# check system config for overrides
if metarace.sysconf.has_option(u'telegraph', u'username'):
self.username = metarace.sysconf.get(u'telegraph', u'username')
if metarace.sysconf.has_option(u'telegraph', u'fullname'):
self.fullname = metarace.sysconf.get(u'telegraph', u'fullname')
if metarace.sysconf.has_option(u'telegraph', u'channel'):
self.channel = metarace.sysconf.get(u'telegraph', u'channel')
if metarace.sysconf.has_option(u'telegraph', u'privateservers'):
self.privateservers = metarace.sysconf.get(u'telegraph',
u'privateservers')
if metarace.sysconf.has_option(u'telegraph', u'opername'):
self.opername = metarace.sysconf.get(u'telegraph', u'opername')
if metarace.sysconf.has_option(u'telegraph', u'operpass'):
self.operpass = metarace.sysconf.get(u'telegraph', u'operpass')
if metarace.sysconf.has_option(u'sender', u'pagelen'):
self.pagelen = strops.confopt_posint(
metarace.sysconf.get(u'sender', u'pagelen'), self.pagelen)
if metarace.sysconf.has_option(u'telegraph', u'ping_interval'):
ck = tod.str2tod(
metarace.sysconf.get(u'telegraph', u'ping_interval'))
if ck is not None:
self.ping_interval = ck
