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