You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
433 lines
16 KiB
433 lines
16 KiB
|
|
#TODO: SSL support (can it be done without back-end openssl?) |
|
from twisted.internet import reactor, protocol |
|
from twisted.internet.endpoints import TCP4ClientEndpoint |
|
from twisted.application.internet import ClientService |
|
from twisted.internet.ssl import ClientContextFactory |
|
from twisted.words.protocols import irc |
|
from jmdaemon.message_channel import MessageChannel |
|
from jmbase.support import get_log, chunks |
|
from txtorcon.socks import TorSocksEndpoint |
|
from jmdaemon.protocol import * |
|
MAX_PRIVMSG_LEN = 450 |
|
|
|
log = get_log() |
|
|
|
def wlog(*x): |
|
"""Simplifier to add lists to the debug log |
|
""" |
|
def conv(s): |
|
if isinstance(s, str): |
|
return s |
|
elif isinstance(s, bytes): |
|
return s.decode('utf-8', errors='ignore') |
|
else: |
|
return str(s) |
|
|
|
if x[0] == "WARNING": |
|
msg = " ".join([conv(a) for a in x[1:]]) |
|
log.warning(msg) |
|
elif x[0] == "INFO": |
|
msg = " ".join([conv(a) for a in x[1:]]) |
|
log.info(msg) |
|
else: |
|
msg = " ".join([conv(a) for a in x]) |
|
log.debug(msg) |
|
|
|
def get_irc_text(line): |
|
return line[line[1:].find(':') + 2:] |
|
|
|
|
|
def get_irc_nick(source): |
|
full_nick = source[0:source.find('!')] |
|
return full_nick[:NICK_MAX_ENCODED+2] |
|
|
|
|
|
def get_config_irc_channel(chan_name, btcnet): |
|
channel = "#" + chan_name |
|
if btcnet == "testnet": |
|
channel += "-test" |
|
elif btcnet == "testnet4": |
|
channel += "-test4" |
|
elif btcnet == "signet": |
|
channel += "-sig" |
|
return channel |
|
|
|
class TxIRCFactory(protocol.ReconnectingClientFactory): |
|
def __init__(self, wrapper): |
|
self.wrapper = wrapper |
|
self.channel = self.wrapper.channel |
|
|
|
def buildProtocol(self, addr): |
|
p = txIRC_Client(self.wrapper) |
|
p.factory = self |
|
self.wrapper.set_tx_irc_client(p) |
|
return p |
|
|
|
def clientConnectionLost(self, connector, reason): |
|
log.debug('IRC connection lost: ' + str(reason)) |
|
if not self.wrapper.give_up: |
|
if reactor.running: |
|
log.info('Attempting to reconnect...') |
|
protocol.ReconnectingClientFactory.clientConnectionLost(self, |
|
connector, reason) |
|
|
|
def clientConnectionFailed(self, connector, reason): |
|
log.info('IRC connection failed') |
|
if not self.wrapper.give_up: |
|
if reactor.running: |
|
log.info('Attempting to reconnect...') |
|
protocol.ReconnectingClientFactory.clientConnectionFailed(self, |
|
connector, reason) |
|
|
|
class IRCMessageChannel(MessageChannel): |
|
|
|
def __init__(self, |
|
configdata, |
|
username='username', |
|
realname='realname', |
|
password=None, |
|
daemon=None): |
|
MessageChannel.__init__(self, daemon=daemon) |
|
self.give_up = True |
|
self.serverport = (configdata['host'], int(configdata['port'])) |
|
#default hostid for use with miniircd which doesnt send NETWORK |
|
self.hostid = configdata['host'] + str(configdata['port']) |
|
self.socks5 = configdata["socks5"] |
|
self.usessl = configdata["usessl"] |
|
if self.socks5.lower() == 'true': |
|
self.socks5_host = configdata["socks5_host"] |
|
self.socks5_port = int(configdata["socks5_port"]) |
|
self.channel = get_config_irc_channel(configdata["channel"], |
|
configdata["btcnet"]) |
|
self.userrealname = (username, realname) |
|
if password and len(password) == 0: |
|
password = None |
|
self.password = password |
|
|
|
self.tx_irc_client = None |
|
#TODO can be configuration var, how long between reconnect attempts: |
|
self.reconnect_interval = 10 |
|
|
|
# service is used to wrap endpoints for Tor connections: |
|
self.reconnecting_service = None |
|
|
|
#implementation of abstract base class methods; |
|
#these are mostly but not exclusively acting as pass through |
|
#to the wrapped twisted IRC client protocol |
|
def run(self): |
|
self.give_up = False |
|
self.build_irc() |
|
|
|
def shutdown(self): |
|
self.tx_irc_client.quit() |
|
self.give_up = True |
|
if self.reconnecting_service: |
|
self.reconnecting_service.stopService() |
|
|
|
def _pubmsg(self, msg): |
|
self.tx_irc_client._pubmsg(msg) |
|
|
|
def _privmsg(self, nick, cmd, msg): |
|
self.tx_irc_client._privmsg(nick, cmd, msg) |
|
|
|
def change_nick(self, new_nick): |
|
self.tx_irc_client.setNick(new_nick) |
|
|
|
def _announce_orders(self, offerlist): |
|
self.tx_irc_client._announce_orders(offerlist) |
|
#end ABC impl. |
|
|
|
def set_tx_irc_client(self, txircclt): |
|
self.tx_irc_client = txircclt |
|
|
|
def build_irc(self): |
|
"""The main starting method that creates a protocol object |
|
according to the config variables, ready for whenever |
|
the reactor starts running. |
|
""" |
|
wlog('building irc') |
|
if self.tx_irc_client: |
|
raise Exception('irc already built') |
|
if self.usessl.lower() == 'true': |
|
ctx = ClientContextFactory() |
|
if self.usessl.lower() == 'true' and not self.socks5.lower() == 'true': |
|
factory = TxIRCFactory(self) |
|
wlog('build_irc: ', self.serverport[0], str(self.serverport[1]), |
|
self.channel) |
|
reactor.connectSSL(self.serverport[0], self.serverport[1], |
|
factory, ctx) |
|
elif self.socks5.lower() == 'true': |
|
factory = TxIRCFactory(self) |
|
wlog('build_irc: ', self.serverport[0], str(self.serverport[1]), |
|
self.channel, str(self.socks5_host), self.socks5_port) |
|
#str() casts needed else unicode error |
|
torEndpoint = TCP4ClientEndpoint(reactor, str(self.socks5_host), |
|
self.socks5_port) |
|
if self.usessl.lower() == 'true': |
|
use_tls = ctx |
|
else: |
|
use_tls = False |
|
ircEndpoint = TorSocksEndpoint(torEndpoint, self.serverport[0], |
|
self.serverport[1], tls=use_tls) |
|
self.reconnecting_service = ClientService(ircEndpoint, factory) |
|
self.reconnecting_service.startService() |
|
else: |
|
try: |
|
factory = TxIRCFactory(self) |
|
wlog('build_irc: ', self.serverport[0], str(self.serverport[1]), |
|
self.channel) |
|
self.tcp_connector = reactor.connectTCP( |
|
self.serverport[0], self.serverport[1], factory) |
|
except Exception as e: |
|
wlog('error in buildirc: ' + repr(e)) |
|
|
|
class txIRC_Client(irc.IRCClient, object): |
|
""" |
|
lineRate is a class variable in the superclass used to limit |
|
messages / second. heartbeat is what you'd think. |
|
""" |
|
#In previous implementation, 450 bytes per second over the last 4 seconds |
|
#was used as the rate limiter/throttle parameter. |
|
#Since we still have max_privmsg_len = 450, that corresponds to a lineRate |
|
#value of 1.0 (seconds). Bumped to 1.3 here for breathing room. |
|
lineRate = 1.3 |
|
heartbeatinterval = 60 |
|
|
|
def __init__(self, wrapper): |
|
self.wrapper = wrapper |
|
self.channel = self.wrapper.channel |
|
self.nickname = self.wrapper.nick |
|
self.password = self.wrapper.password |
|
self.hostname = self.wrapper.serverport[0] |
|
self.built_privmsg = {} |
|
# todo: build pong timeout watchdot |
|
|
|
def irc_unknown(self, prefix, command, params): |
|
pass |
|
|
|
def irc_PONG(self, *args, **kwargs): |
|
# todo: pong called getattr() style. use for health |
|
pass |
|
|
|
def connectionMade(self): |
|
return irc.IRCClient.connectionMade(self) |
|
|
|
def connectionLost(self, reason=protocol.connectionDone): |
|
wlog("INFO", "Lost IRC connection to: " + str(self.hostname) |
|
+ " . Should reconnect automatically soon.") |
|
if not self.wrapper.give_up and self.wrapper.on_disconnect: |
|
reactor.callLater(0.0, self.wrapper.on_disconnect, self.wrapper) |
|
return irc.IRCClient.connectionLost(self, reason) |
|
|
|
def send(self, send_to, msg): |
|
# todo: use proper twisted IRC support (encoding + sendCommand) |
|
omsg = 'PRIVMSG %s :' % (send_to,) + msg |
|
self.sendLine(omsg) |
|
|
|
def _pubmsg(self, message): |
|
self.send(self.channel, message) |
|
|
|
def _privmsg(self, nick, cmd, message): |
|
header = "PRIVMSG " + nick + " :" |
|
max_chunk_len = MAX_PRIVMSG_LEN - len(header) - len(cmd) - 4 |
|
# 1 for command prefix 1 for space 2 for trailer |
|
if len(message) > max_chunk_len: |
|
message_chunks = chunks(message, max_chunk_len) |
|
else: |
|
message_chunks = [message] |
|
for m in message_chunks: |
|
trailer = ' ~' if m == message_chunks[-1] else ' ;' |
|
if m == message_chunks[0]: |
|
m = COMMAND_PREFIX + cmd + ' ' + m |
|
self.send(nick, m + trailer) |
|
|
|
def _announce_orders(self, offerlist): |
|
"""This publishes orders to the pit and to |
|
counterparties. Note that it does *not* use chunking. |
|
So, it tries to optimise space usage thusly: |
|
As many complete orderlines are fit onto one line |
|
as possible, and overflow goes onto another line. |
|
Each list entry in orderlist must have format: |
|
!ordername <parameters> |
|
|
|
Then, what is published is lines of form: |
|
!ordername <parameters>!ordername <parameters>.. |
|
|
|
fitting as many list entries as possible onto one line, |
|
up to the limit of the IRC parameters (see MAX_PRIVMSG_LEN). |
|
|
|
Order announce in private is handled by privmsg/_privmsg |
|
using chunking, no longer using this function. |
|
""" |
|
header = 'PRIVMSG ' + self.channel + ' :' |
|
offerlines = [] |
|
for i, offer in enumerate(offerlist): |
|
offerlines.append(offer) |
|
line = header + ''.join(offerlines) + ' ~' |
|
if len(line) > MAX_PRIVMSG_LEN or i == len(offerlist) - 1: |
|
if i < len(offerlist) - 1: |
|
line = header + ''.join(offerlines[:-1]) + ' ~' |
|
self.sendLine(line) |
|
offerlines = [offerlines[-1]] |
|
# --------------------------------------------- |
|
# general callbacks from superclass |
|
# --------------------------------------------- |
|
|
|
def signedOn(self): |
|
wlog('signedOn: ', self.hostname) |
|
self.join(self.factory.channel) |
|
|
|
def joined(self, channel): |
|
wlog("INFO", "joined: " + str(channel) + " " + str(self.hostname)) |
|
# for admin purposes, IRC servers *usually* require bots to identify |
|
# themselves as such: |
|
self.sendLine("MODE " + self.nickname + " +B") |
|
#Use as trigger for start to mcc: |
|
reactor.callLater(0.0, self.wrapper.on_welcome, self.wrapper) |
|
|
|
def privmsg(self, userIn, channel, msg): |
|
reactor.callLater(0.0, self.handle_privmsg, |
|
userIn, channel, msg) |
|
|
|
def __on_privmsg(self, nick, msg): |
|
self.wrapper.on_privmsg(nick, msg) |
|
|
|
def __on_pubmsg(self, nick, msg): |
|
self.wrapper.on_pubmsg(nick, msg) |
|
|
|
def handle_privmsg(self, sent_from, sent_to, message): |
|
try: |
|
nick = get_irc_nick(sent_from) |
|
# todo: kludge - we need this elsewhere. rearchitect!! |
|
self.from_to = (nick, sent_to) |
|
if sent_to == self.wrapper.nick: |
|
if nick not in self.built_privmsg: |
|
if message[0] != COMMAND_PREFIX: |
|
wlog('bad command ', message) |
|
return |
|
|
|
# new message starting |
|
cmd_string = message[1:].split(' ')[0] |
|
self.built_privmsg[nick] = [cmd_string, message[:-2]] |
|
else: |
|
self.built_privmsg[nick][1] += message[:-2] |
|
if message[-1] == ';': |
|
pass |
|
elif message[-1] == '~': |
|
parsed = self.built_privmsg[nick][1] |
|
# wipe the message buffer waiting for the next one |
|
del self.built_privmsg[nick] |
|
self.__on_privmsg(nick, parsed) |
|
else: |
|
# drop the bad nick |
|
del self.built_privmsg[nick] |
|
elif sent_to == self.channel: |
|
self.__on_pubmsg(nick, message) |
|
else: |
|
wlog('what is this?: ', sent_from, sent_to, message[:80]) |
|
except: |
|
wlog('unable to parse privmsg, msg: ', message) |
|
|
|
def action(self, user, channel, msg): |
|
pass |
|
#wlog('unhandled action: ', user, channel, msg) |
|
|
|
def irc_ERR_NICKNAMEINUSE(self, prefix, params): |
|
""" |
|
Called when we try to register or change to a nickname that is already |
|
taken. |
|
This is overriden from base class to insist on retrying with the same |
|
nickname, after a hardcoded 10s timeout. The user is amply warned at |
|
WARNING logging level, and can just restart if they are around to see it. |
|
""" |
|
wlog("WARNING", "Your nickname is in use. This usually happens " |
|
"as a result of a network failure. You are recommended to " |
|
"restart, otherwise you should regain your nick after " |
|
"some time. This is not a security risk, but you may lose " |
|
"access to coinjoins during this period.") |
|
reactor.callLater(10.0, self.setNick, self._attemptedNick) |
|
|
|
def modeChanged(self, user, channel, _set, modes, args): |
|
pass |
|
#wlog('(unhandled) modeChanged: ', user, channel, _set, modes, args) |
|
|
|
def pong(self, user, secs): |
|
pass |
|
#wlog('pong: ', user, secs) |
|
|
|
def userJoined(self, user, channel): |
|
pass |
|
#wlog('user joined: ', user, channel) |
|
|
|
def userKicked(self, kickee, channel, kicker, message): |
|
#wlog('kicked: ', kickee, channel, kicker, message) |
|
if self.wrapper.on_nick_leave: |
|
reactor.callLater(0.0, self.wrapper.on_nick_leave, kickee, self.wrapper) |
|
|
|
def userLeft(self, user, channel): |
|
#wlog('left: ', user, channel) |
|
if self.wrapper.on_nick_leave: |
|
reactor.callLater(0.0, self.wrapper.on_nick_leave, user, self.wrapper) |
|
|
|
def userRenamed(self, oldname, newname): |
|
wlog('rename: ', oldname, newname) |
|
#TODO nick change handling |
|
|
|
def userQuit(self, user, quitMessage): |
|
#wlog('userQuit: ', user, quitMessage) |
|
if self.wrapper.on_nick_leave: |
|
reactor.callLater(0.0, self.wrapper.on_nick_leave, user, self.wrapper) |
|
|
|
def topicUpdated(self, user, channel, newTopic): |
|
wlog('topicUpdated: ', user, channel, newTopic) |
|
if self.wrapper.on_set_topic: |
|
reactor.callLater(0.0, self.wrapper.on_set_topic, newTopic) |
|
|
|
def receivedMOTD(self, motd): |
|
pass |
|
#wlog('motd: ', motd) |
|
|
|
def created(self, when): |
|
pass |
|
#wlog('(unhandled) created: ', when) |
|
|
|
def yourHost(self, info): |
|
pass |
|
#wlog('(unhandled) yourhost: ', info) |
|
|
|
def isupport(self, options): |
|
"""Used to set the name of the IRC *network* |
|
(as distinct from the individual server), used |
|
for signature replay defence (see signing code in message_channel.py). |
|
If this option ("NETWORK") is not found, we fallback to the default |
|
hostid = servername+port as shown in IRCMessageChannel (should only |
|
happen in testing). |
|
""" |
|
for o in options: |
|
try: |
|
k, v = o.split('=') |
|
if k == 'NETWORK': |
|
self.wrapper.hostid = v |
|
except Exception as e: |
|
pass |
|
#wlog('failed to parse isupport option, ignoring') |
|
|
|
def myInfo(self, servername, version, umodes, cmodes): |
|
pass |
|
#wlog('(unhandled) myInfo: ', servername, version, umodes, cmodes) |
|
|
|
def luserChannels(self, channels): |
|
pass |
|
#wlog('(unhandled) luserChannels: ', channels) |
|
|
|
def bounce(self, info): |
|
pass |
|
#wlog('(unhandled) bounce: ', info) |
|
|
|
def left(self, channel): |
|
pass |
|
#wlog('(unhandled) left: ', channel) |
|
|
|
def noticed(self, user, channel, message): |
|
wlog('(unhandled) noticed: ', user, channel, message)
|
|
|