2013-02-22 21:43:27 +01:00
|
|
|
##
|
2005-01-19 14:14:38 +01:00
|
|
|
# Copyright (c) 2002-2004, Jeremiah Fincher
|
2013-08-23 05:43:09 +02:00
|
|
|
# Copyright (c) 2010, 2013, James McCoy
|
2005-01-19 14:14:38 +01:00
|
|
|
# All rights reserved.
|
|
|
|
#
|
|
|
|
# Redistribution and use in source and binary forms, with or without
|
|
|
|
# modification, are permitted provided that the following conditions are met:
|
|
|
|
#
|
|
|
|
# * Redistributions of source code must retain the above copyright notice,
|
|
|
|
# this list of conditions, and the following disclaimer.
|
|
|
|
# * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
# this list of conditions, and the following disclaimer in the
|
|
|
|
# documentation and/or other materials provided with the distribution.
|
|
|
|
# * Neither the name of the author of this software nor the name of
|
|
|
|
# contributors to this software may be used to endorse or promote products
|
|
|
|
# derived from this software without specific prior written consent.
|
|
|
|
#
|
|
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
###
|
|
|
|
|
|
|
|
"""
|
|
|
|
Contains simple socket drivers. Asyncore bugged (haha, pun!) me.
|
|
|
|
"""
|
|
|
|
|
|
|
|
from __future__ import division
|
|
|
|
|
2013-12-03 06:44:50 +01:00
|
|
|
import os
|
2005-01-19 14:14:38 +01:00
|
|
|
import time
|
2013-06-29 13:44:42 +02:00
|
|
|
import errno
|
2005-01-19 14:14:38 +01:00
|
|
|
import select
|
|
|
|
import socket
|
|
|
|
|
2015-08-31 15:38:35 +02:00
|
|
|
from .. import (conf, drivers, log, utils, world)
|
2015-08-11 16:50:23 +02:00
|
|
|
from ..utils import minisix
|
2015-05-16 00:30:20 +02:00
|
|
|
from ..utils.str import decode_raw_line
|
2005-01-19 14:14:38 +01:00
|
|
|
|
2010-12-09 19:33:35 +01:00
|
|
|
try:
|
|
|
|
import ssl
|
2010-12-12 14:33:36 +01:00
|
|
|
SSLError = ssl.SSLError
|
2010-12-09 19:33:35 +01:00
|
|
|
except:
|
2012-04-03 17:14:07 +02:00
|
|
|
drivers.log.debug('ssl module is not available, '
|
|
|
|
'cannot connect to SSL servers.')
|
2010-12-12 14:33:36 +01:00
|
|
|
class SSLError(Exception):
|
|
|
|
pass
|
2005-01-19 14:14:38 +01:00
|
|
|
|
|
|
|
|
|
|
|
class SocketDriver(drivers.IrcDriver, drivers.ServersMixin):
|
2012-12-07 21:41:50 +01:00
|
|
|
_instances = []
|
|
|
|
_selecting = [False] # We want it to be mutable.
|
2005-01-19 14:14:38 +01:00
|
|
|
def __init__(self, irc):
|
2012-12-07 21:41:50 +01:00
|
|
|
self._instances.append(self)
|
2013-06-01 12:08:12 +02:00
|
|
|
assert irc is not None
|
2005-01-19 14:14:38 +01:00
|
|
|
self.irc = irc
|
2009-01-28 06:31:45 +01:00
|
|
|
drivers.IrcDriver.__init__(self, irc)
|
|
|
|
drivers.ServersMixin.__init__(self, irc)
|
2005-01-19 14:14:38 +01:00
|
|
|
self.conn = None
|
2013-05-31 17:21:10 +02:00
|
|
|
self._attempt = -1
|
2005-01-19 14:14:38 +01:00
|
|
|
self.servers = ()
|
|
|
|
self.eagains = 0
|
2012-08-04 12:00:02 +02:00
|
|
|
self.inbuffer = b''
|
2005-01-19 14:14:38 +01:00
|
|
|
self.outbuffer = ''
|
|
|
|
self.zombie = False
|
|
|
|
self.connected = False
|
2010-05-25 05:36:29 +02:00
|
|
|
self.writeCheckTime = None
|
|
|
|
self.nextReconnectTime = None
|
2005-05-20 01:39:19 +02:00
|
|
|
self.resetDelay()
|
Start accelerating the 2to3 step (remove fix_apply, fix_buffer, fix_callable, fix_exec, fix_execfile, fix_exitfunc, fix_filter, fix_funcattrs, fix_future, fix_getcwdu, and fix_has_key).
2014-01-20 14:49:47 +01:00
|
|
|
if self.networkGroup.get('ssl').value and 'ssl' not in globals():
|
2005-05-20 01:38:55 +02:00
|
|
|
drivers.log.error('The Socket driver can not connect to SSL '
|
2010-12-09 19:33:35 +01:00
|
|
|
'servers for your Python version. Try the '
|
|
|
|
'Twisted driver instead, or install a Python'
|
|
|
|
'version that supports SSL (2.6 and greater).')
|
2005-03-11 19:37:02 +01:00
|
|
|
else:
|
|
|
|
self.connect()
|
2005-01-19 14:14:38 +01:00
|
|
|
|
2005-05-20 01:39:19 +02:00
|
|
|
def getDelay(self):
|
|
|
|
ret = self.currentDelay
|
|
|
|
self.currentDelay = min(self.currentDelay * 2,
|
|
|
|
conf.supybot.drivers.maxReconnectWait())
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def resetDelay(self):
|
|
|
|
self.currentDelay = 10.0
|
|
|
|
|
2005-01-19 14:14:38 +01:00
|
|
|
def _getNextServer(self):
|
|
|
|
oldServer = getattr(self, 'currentServer', None)
|
2009-01-28 06:31:45 +01:00
|
|
|
server = drivers.ServersMixin._getNextServer(self)
|
2005-01-19 14:14:38 +01:00
|
|
|
if self.currentServer != oldServer:
|
2005-05-20 01:39:19 +02:00
|
|
|
self.resetDelay()
|
2005-01-19 14:14:38 +01:00
|
|
|
return server
|
|
|
|
|
|
|
|
def _handleSocketError(self, e):
|
|
|
|
# (11, 'Resource temporarily unavailable') raised if connect
|
|
|
|
# hasn't finished yet. We'll keep track of how many we get.
|
2008-05-12 19:21:48 +02:00
|
|
|
if e.args[0] != 11 or self.eagains > 120:
|
2005-01-19 14:14:38 +01:00
|
|
|
drivers.log.disconnect(self.currentServer, e)
|
2012-12-07 21:41:50 +01:00
|
|
|
if self in self._instances:
|
|
|
|
self._instances.remove(self)
|
2010-05-25 05:36:29 +02:00
|
|
|
try:
|
|
|
|
self.conn.close()
|
|
|
|
except:
|
|
|
|
pass
|
|
|
|
self.connected = False
|
2005-05-20 01:39:19 +02:00
|
|
|
self.scheduleReconnect()
|
2005-01-19 14:14:38 +01:00
|
|
|
else:
|
|
|
|
log.debug('Got EAGAIN, current count: %s.', self.eagains)
|
|
|
|
self.eagains += 1
|
|
|
|
|
|
|
|
def _sendIfMsgs(self):
|
2013-08-09 12:59:42 +02:00
|
|
|
if not self.connected:
|
|
|
|
return
|
2005-01-19 14:14:38 +01:00
|
|
|
if not self.zombie:
|
|
|
|
msgs = [self.irc.takeMsg()]
|
|
|
|
while msgs[-1] is not None:
|
|
|
|
msgs.append(self.irc.takeMsg())
|
|
|
|
del msgs[-1]
|
2014-01-21 10:50:55 +01:00
|
|
|
self.outbuffer += ''.join(map(str, msgs))
|
2005-01-19 14:14:38 +01:00
|
|
|
if self.outbuffer:
|
|
|
|
try:
|
2015-08-09 00:23:03 +02:00
|
|
|
if minisix.PY2:
|
2012-08-05 13:47:48 +02:00
|
|
|
sent = self.conn.send(self.outbuffer)
|
|
|
|
else:
|
|
|
|
sent = self.conn.send(self.outbuffer.encode())
|
2005-01-19 14:14:38 +01:00
|
|
|
self.outbuffer = self.outbuffer[sent:]
|
|
|
|
self.eagains = 0
|
2014-01-20 15:49:15 +01:00
|
|
|
except socket.error as e:
|
2005-01-19 14:14:38 +01:00
|
|
|
self._handleSocketError(e)
|
|
|
|
if self.zombie and not self.outbuffer:
|
|
|
|
self._reallyDie()
|
|
|
|
|
2012-12-07 21:41:50 +01:00
|
|
|
@classmethod
|
|
|
|
def _select(cls):
|
|
|
|
if cls._selecting[0]:
|
|
|
|
return
|
|
|
|
try:
|
|
|
|
cls._selecting[0] = True
|
|
|
|
for inst in cls._instances:
|
|
|
|
# Do not use a list comprehension here, we have to edit the list
|
|
|
|
# and not to reassign it.
|
2013-08-09 12:59:42 +02:00
|
|
|
if not inst.connected or \
|
2015-08-09 00:23:03 +02:00
|
|
|
(minisix.PY3 and inst.conn._closed) or \
|
|
|
|
(minisix.PY2 and
|
2012-12-26 15:03:57 +01:00
|
|
|
inst.conn._sock.__class__ is socket._closedsocket):
|
2012-12-07 21:41:50 +01:00
|
|
|
cls._instances.remove(inst)
|
2013-11-09 16:47:00 +01:00
|
|
|
elif inst.conn.fileno() == -1:
|
|
|
|
inst.reconnect()
|
2012-12-07 21:41:50 +01:00
|
|
|
if not cls._instances:
|
|
|
|
return
|
|
|
|
rlist, wlist, xlist = select.select([x.conn for x in cls._instances],
|
|
|
|
[], [], conf.supybot.drivers.poll())
|
|
|
|
for instance in cls._instances:
|
|
|
|
if instance.conn in rlist:
|
|
|
|
instance._read()
|
2013-06-29 13:44:42 +02:00
|
|
|
except select.error as e:
|
|
|
|
if e.args[0] != errno.EINTR:
|
|
|
|
# 'Interrupted system call'
|
|
|
|
raise
|
2012-12-07 21:41:50 +01:00
|
|
|
finally:
|
|
|
|
cls._selecting[0] = False
|
|
|
|
for instance in cls._instances:
|
2012-12-26 19:58:39 +01:00
|
|
|
if instance.irc and not instance.irc.zombie:
|
2012-12-07 21:41:50 +01:00
|
|
|
instance._sendIfMsgs()
|
|
|
|
|
|
|
|
|
2005-01-19 14:14:38 +01:00
|
|
|
def run(self):
|
2010-05-25 05:36:29 +02:00
|
|
|
now = time.time()
|
|
|
|
if self.nextReconnectTime is not None and now > self.nextReconnectTime:
|
|
|
|
self.reconnect()
|
|
|
|
elif self.writeCheckTime is not None and now > self.writeCheckTime:
|
|
|
|
self._checkAndWriteOrReconnect()
|
2005-01-19 14:14:38 +01:00
|
|
|
if not self.connected:
|
|
|
|
# We sleep here because otherwise, if we're the only driver, we'll
|
|
|
|
# spin at 100% CPU while we're disconnected.
|
|
|
|
time.sleep(conf.supybot.drivers.poll())
|
|
|
|
return
|
|
|
|
self._sendIfMsgs()
|
2012-12-07 21:41:50 +01:00
|
|
|
self._select()
|
|
|
|
|
|
|
|
def _read(self):
|
|
|
|
"""Called by _select() when we can read data."""
|
2005-01-19 14:14:38 +01:00
|
|
|
try:
|
|
|
|
self.inbuffer += self.conn.recv(1024)
|
2005-05-20 01:39:19 +02:00
|
|
|
self.eagains = 0 # If we successfully recv'ed, we can reset this.
|
2012-08-04 12:00:02 +02:00
|
|
|
lines = self.inbuffer.split(b'\n')
|
2005-01-19 14:14:38 +01:00
|
|
|
self.inbuffer = lines.pop()
|
|
|
|
for line in lines:
|
2015-05-16 00:30:20 +02:00
|
|
|
line = decode_raw_line(line)
|
2013-06-27 19:36:44 +02:00
|
|
|
|
2005-01-19 14:14:38 +01:00
|
|
|
msg = drivers.parseMsg(line)
|
2013-12-05 13:37:00 +01:00
|
|
|
if msg is not None and self.irc is not None:
|
2005-01-19 14:14:38 +01:00
|
|
|
self.irc.feedMsg(msg)
|
|
|
|
except socket.timeout:
|
|
|
|
pass
|
2014-01-20 15:49:15 +01:00
|
|
|
except SSLError as e:
|
2010-12-09 19:33:35 +01:00
|
|
|
if e.args[0] == 'The read operation timed out':
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
self._handleSocketError(e)
|
|
|
|
return
|
2014-01-20 15:49:15 +01:00
|
|
|
except socket.error as e:
|
2005-01-19 14:14:38 +01:00
|
|
|
self._handleSocketError(e)
|
|
|
|
return
|
2013-12-27 14:15:45 +01:00
|
|
|
if self.irc and not self.irc.zombie:
|
2005-01-19 14:14:38 +01:00
|
|
|
self._sendIfMsgs()
|
|
|
|
|
|
|
|
def connect(self, **kwargs):
|
|
|
|
self.reconnect(reset=False, **kwargs)
|
|
|
|
|
2013-08-24 06:29:16 +02:00
|
|
|
def reconnect(self, wait=False, reset=True):
|
2013-05-31 17:21:10 +02:00
|
|
|
self._attempt += 1
|
2010-05-25 05:36:29 +02:00
|
|
|
self.nextReconnectTime = None
|
2005-01-19 14:14:38 +01:00
|
|
|
if self.connected:
|
|
|
|
drivers.log.reconnect(self.irc.network)
|
2012-12-07 21:41:50 +01:00
|
|
|
if self in self._instances:
|
|
|
|
self._instances.remove(self)
|
2013-01-31 16:47:17 +01:00
|
|
|
try:
|
|
|
|
self.conn.shutdown(socket.SHUT_RDWR)
|
|
|
|
except: # "Transport endpoint not connected"
|
|
|
|
pass
|
2005-01-19 14:14:38 +01:00
|
|
|
self.conn.close()
|
|
|
|
self.connected = False
|
|
|
|
if reset:
|
|
|
|
drivers.log.debug('Resetting %s.', self.irc)
|
|
|
|
self.irc.reset()
|
|
|
|
else:
|
|
|
|
drivers.log.debug('Not resetting %s.', self.irc)
|
2013-08-24 06:29:16 +02:00
|
|
|
if wait:
|
|
|
|
self.scheduleReconnect()
|
|
|
|
return
|
2005-01-19 14:14:38 +01:00
|
|
|
server = self._getNextServer()
|
2013-08-17 15:47:27 +02:00
|
|
|
socks_proxy = getattr(conf.supybot.networks, self.irc.network) \
|
|
|
|
.socksproxy()
|
2013-08-09 12:59:42 +02:00
|
|
|
try:
|
2013-08-17 15:47:27 +02:00
|
|
|
if socks_proxy:
|
|
|
|
import socks
|
|
|
|
except ImportError:
|
|
|
|
log.error('Cannot use socks proxy (SocksiPy not installed), '
|
|
|
|
'using direct connection instead.')
|
|
|
|
socks_proxy = ''
|
|
|
|
if socks_proxy:
|
|
|
|
address = server[0]
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
address = utils.net.getAddressFromHostname(server[0],
|
|
|
|
attempt=self._attempt)
|
2014-08-30 12:10:48 +02:00
|
|
|
except (socket.gaierror, socket.error) as e:
|
2013-08-17 15:47:27 +02:00
|
|
|
drivers.log.connectError(self.currentServer, e)
|
|
|
|
self.scheduleReconnect()
|
|
|
|
return
|
2014-03-01 09:22:14 +01:00
|
|
|
port = server[1]
|
2005-01-19 14:14:38 +01:00
|
|
|
drivers.log.connect(self.currentServer)
|
|
|
|
try:
|
2014-03-01 09:22:14 +01:00
|
|
|
self.conn = utils.net.getSocket(address, port=port,
|
2015-08-30 17:33:39 +02:00
|
|
|
socks_proxy=socks_proxy,
|
|
|
|
vhost=conf.supybot.protocols.irc.vhost(),
|
|
|
|
vhostv6=conf.supybot.protocols.irc.vhostv6(),
|
|
|
|
)
|
2014-01-20 15:49:15 +01:00
|
|
|
except socket.error as e:
|
2005-01-19 14:14:38 +01:00
|
|
|
drivers.log.connectError(self.currentServer, e)
|
2005-05-20 01:39:19 +02:00
|
|
|
self.scheduleReconnect()
|
2005-01-19 14:14:38 +01:00
|
|
|
return
|
|
|
|
# We allow more time for the connect here, since it might take longer.
|
|
|
|
# At least 10 seconds.
|
|
|
|
self.conn.settimeout(max(10, conf.supybot.drivers.poll()*10))
|
|
|
|
try:
|
2013-03-21 18:21:20 +01:00
|
|
|
if getattr(conf.supybot.networks, self.irc.network).ssl():
|
Start accelerating the 2to3 step (remove fix_apply, fix_buffer, fix_callable, fix_exec, fix_execfile, fix_exitfunc, fix_filter, fix_funcattrs, fix_future, fix_getcwdu, and fix_has_key).
2014-01-20 14:49:47 +01:00
|
|
|
assert 'ssl' in globals()
|
2013-11-10 11:45:01 +01:00
|
|
|
certfile = getattr(conf.supybot.networks, self.irc.network) \
|
|
|
|
.certfile()
|
2014-06-04 18:58:43 +02:00
|
|
|
if not certfile:
|
|
|
|
certfile = conf.supybot.protocols.irc.certfile()
|
2013-11-27 17:43:42 +01:00
|
|
|
if not certfile:
|
|
|
|
certfile = None
|
|
|
|
elif not os.path.isfile(certfile):
|
2013-11-27 08:24:49 +01:00
|
|
|
drivers.log.warning('Could not find cert file %s.' %
|
|
|
|
certfile)
|
|
|
|
certfile = None
|
|
|
|
self.conn = ssl.wrap_socket(self.conn, certfile=certfile)
|
2013-05-31 17:21:10 +02:00
|
|
|
self.conn.connect((address, server[1]))
|
2012-10-10 19:39:28 +02:00
|
|
|
def setTimeout():
|
|
|
|
self.conn.settimeout(conf.supybot.drivers.poll())
|
|
|
|
conf.supybot.drivers.poll.addCallback(setTimeout)
|
|
|
|
setTimeout()
|
2005-05-20 01:39:19 +02:00
|
|
|
self.connected = True
|
|
|
|
self.resetDelay()
|
2014-01-20 15:49:15 +01:00
|
|
|
except socket.error as e:
|
2005-01-19 14:14:38 +01:00
|
|
|
if e.args[0] == 115:
|
|
|
|
now = time.time()
|
|
|
|
when = now + 60
|
|
|
|
whenS = log.timestamp(when)
|
|
|
|
drivers.log.debug('Connection in progress, scheduling '
|
|
|
|
'connectedness check for %s', whenS)
|
2010-05-25 05:36:29 +02:00
|
|
|
self.writeCheckTime = when
|
2005-01-19 14:14:38 +01:00
|
|
|
else:
|
|
|
|
drivers.log.connectError(self.currentServer, e)
|
2005-05-20 01:39:19 +02:00
|
|
|
self.scheduleReconnect()
|
2005-01-19 14:14:38 +01:00
|
|
|
return
|
2012-12-07 21:41:50 +01:00
|
|
|
self._instances.append(self)
|
2005-01-19 14:14:38 +01:00
|
|
|
|
|
|
|
def _checkAndWriteOrReconnect(self):
|
2010-05-25 05:36:29 +02:00
|
|
|
self.writeCheckTime = None
|
2005-01-19 14:14:38 +01:00
|
|
|
drivers.log.debug('Checking whether we are connected.')
|
|
|
|
(_, w, _) = select.select([], [self.conn], [], 0)
|
|
|
|
if w:
|
|
|
|
drivers.log.debug('Socket is writable, it might be connected.')
|
|
|
|
self.connected = True
|
2005-05-20 01:39:19 +02:00
|
|
|
self.resetDelay()
|
2005-01-19 14:14:38 +01:00
|
|
|
else:
|
|
|
|
drivers.log.connectError(self.currentServer, 'Timed out')
|
|
|
|
self.reconnect()
|
|
|
|
|
2005-05-20 01:39:19 +02:00
|
|
|
def scheduleReconnect(self):
|
|
|
|
when = time.time() + self.getDelay()
|
2005-01-19 14:14:38 +01:00
|
|
|
if not world.dying:
|
|
|
|
drivers.log.reconnect(self.irc.network, when)
|
2010-05-25 05:36:29 +02:00
|
|
|
if self.nextReconnectTime:
|
|
|
|
drivers.log.error('Updating next reconnect time when one is '
|
|
|
|
'already present. This is a bug; please '
|
2005-05-20 01:39:19 +02:00
|
|
|
'report it, with an explanation of what caused '
|
|
|
|
'this to happen.')
|
2010-05-25 05:36:29 +02:00
|
|
|
self.nextReconnectTime = when
|
2005-01-19 14:14:38 +01:00
|
|
|
|
|
|
|
def die(self):
|
2012-12-07 21:41:50 +01:00
|
|
|
if self in self._instances:
|
|
|
|
self._instances.remove(self)
|
2005-01-19 14:14:38 +01:00
|
|
|
self.zombie = True
|
2010-05-25 05:36:29 +02:00
|
|
|
if self.nextReconnectTime is not None:
|
|
|
|
self.nextReconnectTime = None
|
|
|
|
if self.writeCheckTime is not None:
|
|
|
|
self.writeCheckTime = None
|
2005-01-19 14:14:38 +01:00
|
|
|
drivers.log.die(self.irc)
|
|
|
|
|
|
|
|
def _reallyDie(self):
|
|
|
|
if self.conn is not None:
|
|
|
|
self.conn.close()
|
|
|
|
drivers.IrcDriver.die(self)
|
|
|
|
# self.irc.die() Kill off the ircs yourself, jerk!
|
|
|
|
|
|
|
|
def name(self):
|
|
|
|
return '%s(%s)' % (self.__class__.__name__, self.irc)
|
|
|
|
|
|
|
|
|
|
|
|
Driver = SocketDriver
|
|
|
|
|
2006-02-11 16:52:51 +01:00
|
|
|
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
|
2005-01-19 14:14:38 +01:00
|
|
|
|