Merge pull request #31 from effigies/issue_30

BF/PY3: Error handling

BitTornado/Client/Rerequester.py

@@ -1,5 +1,4 @@
 import threading
-import socket
 import random
 from BitTornado.Meta.Info import check_type
 from io import StringIO
@@ -220,7 +219,7 @@ def timedout(self=self, code=code):
                 response = announcer.announce(self.infohash, self.myid,
                                               **kwargs)
                 check_peers(response)
-            except (IOError, socket.error) as e:
+            except (IOError, OSError) as e:
                 if self.lock.trip(code):
                     self.errorcodes['troublecode'] = 'Problem connecting to ' \
                         'tracker - ' + str(e)

BitTornado/Client/launchmanycore.py

@@ -1,5 +1,4 @@
 import os
-import socket
 import threading
 import random
 from io import StringIO
@@ -148,7 +147,7 @@ def __init__(self, config, Output):
                         ipv6_socket_style=config['ipv6_binds_v4'],
                         upnp=upnp_type, randomizer=config['random_port'])
                     break
-                except socket.error as e:
+                except OSError as e:
                     if upnp_type and e == UPnP_ERROR:
                         self.Output.message(
                             'WARNING: COULD NOT FORWARD VIA UPnP')

BitTornado/Network/Encrypter.py

@@ -1,4 +1,3 @@
-import socket
 import urllib
 from binascii import hexlify
 from .BTcrypto import Crypto, padding
@@ -560,7 +559,7 @@ def start_connection(self, dns, peerid, encrypted=None):
             con = Connection(self, c, peerid, encrypted=encrypted)
             self.connections[c] = con
             c.set_handler(con)
-        except socket.error:
+        except OSError:
             return False
         return True
 

BitTornado/Network/NatCheck.py

@@ -1,4 +1,3 @@
-import socket
 from .BTcrypto import Crypto, CRYPTO_OK, padding
 from .Encrypter import protocol_name, option_pattern
 
@@ -29,9 +28,7 @@ def __init__(self, resultfunc, downloadid, peerid, ip, port, rawserver,
             else:
                 self.encrypter = None
                 self.write(protocol_name + bytes(8) + downloadid)
-        except socket.error:
-            self.answer(False)
-        except IOError:
+        except (IOError, OSError):
             self.answer(False)
         self.next_len = len(protocol_name)
         self.next_func = self.read_header

BitTornado/Network/RawServer.py

@@ -13,7 +13,7 @@ def autodetect_ipv6():
     try:
         assert socket.has_ipv6
         socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-    except (AssertionError, socket.error):
+    except (AssertionError, OSError):
         return 0
     return 1
 

BitTornado/Network/SocketHandler.py

@@ -26,7 +26,7 @@ def __init__(self, socket_handler, sock, handler, ip=None):
         self.skipped = 0
         try:
             self.ip = self.socket.getpeername()[0]
-        except socket.error:
+        except OSError:
             if ip is None:
                 self.ip = 'unknown'
             else:
@@ -36,7 +36,7 @@ def get_ip(self, real=False):
         if real:
             try:
                 self.ip = self.socket.getpeername()[0]
-            except socket.error:
+            except OSError:
                 pass
         return self.ip
 
@@ -61,7 +61,10 @@ def close(self):
         sock.close()
 
     def shutdown(self, val):
-        self.socket.shutdown(val)
+        try:
+            self.socket.shutdown(val)
+        except OSError:
+            pass
 
     def is_flushed(self):
         return not self.buffer
@@ -88,9 +91,9 @@ def try_write(self):
                         self.buffer[0] = buf[amount:]
                         break
                     del self.buffer[0]
-            except socket.error as e:
+            except OSError as e:
                 try:
-                    dead = e[0] != EWOULDBLOCK
+                    dead = e.errno != EWOULDBLOCK
                 except Exception:
                     dead = True
                 self.skipped += 1
@@ -162,33 +165,33 @@ def bind(self, port, bind='', reuse=False, ipv6_socket_style=1, upnp=0):
                     self.interfaces.append(server.getsockname()[0])
                 server.listen(64)
                 self.poll.register(server, POLLIN)
-            except socket.error as e:
+            except OSError as e:
                 # servers is a dict of sockets, so there's no danger of
                 # altering self.servers in this loop
                 for server in self.servers.values():
                     try:
                         server.close()
-                    except socket.error:
+                    except OSError:
                         pass
                 if self.ipv6_enable and ipv6_socket_style == 0 and \
                         self.servers:
-                    raise socket.error(
+                    raise OSError(
                         'blocked port (may require ipv6_binds_v4 to be set)')
-                raise socket.error(str(e))
+                raise e
         if not self.servers:
-            raise socket.error('unable to open server port')
+            raise OSError('unable to open server port')
         if upnp:
             if not UPnP_open_port(port):
                 # servers is a dict of sockets, so there's no danger of
                 # altering self.servers in this loop
                 for server in self.servers.values():
                     try:
                         server.close()
-                    except socket.error:
+                    except OSError:
                         pass
                 self.servers = None
                 self.interfaces = None
-                raise socket.error(UPnP_ERROR)
+                raise OSError(UPnP_ERROR)
             self.port_forwarded = port
         self.port = port
 
@@ -204,9 +207,9 @@ def find_and_bind(self, minport, maxport, bind='', reuse=False,
                 self.bind(listen_port, bind,
                           ipv6_socket_style=ipv6_socket_style, upnp=upnp)
                 return listen_port
-            except socket.error as e:
+            except OSError as e:
                 pass
-        raise socket.error(str(e))
+        raise OSError(str(e))
 
     def set_handler(self, handler):
         self.handler = handler
@@ -218,10 +221,10 @@ def start_connection_raw(self, dns, socktype=socket.AF_INET, handler=None):
         sock.setblocking(0)
         try:
             sock.connect_ex(dns)
-        except socket.error:
+        except OSError:
             raise
         except Exception as e:
-            raise socket.error(str(e))
+            raise OSError(str(e))
         self.poll.register(sock, POLLIN)
         s = SingleSocket(self, sock, handler, dns[0])
         self.single_sockets[sock.fileno()] = s
@@ -238,21 +241,21 @@ def start_connection(self, dns, handler=None, randomize=False):
         try:
             addrinfos = socket.getaddrinfo(dns[0], int(dns[1]),
                                            socktype, socket.SOCK_STREAM)
-        except socket.error as e:
+        except OSError as e:
             raise
         except Exception as e:
-            raise socket.error(str(e))
+            raise OSError(str(e))
         if randomize:
             random.shuffle(addrinfos)
         for addrinfo in addrinfos:
             try:
                 s = self.start_connection_raw(addrinfo[4], addrinfo[0],
                                               handler)
                 break
-            except socket.error:
+            except OSError:
                 pass
         else:
-            raise socket.error('unable to connect')
+            raise OSError('unable to connect')
 
         return s
 
@@ -273,7 +276,7 @@ def handle_events(self, events):
                         self.single_sockets[newsock.fileno()] = nss
                         self.poll.register(newsock, POLLIN)
                         self.handler.external_connection_made(nss)
-                    except socket.error:
+                    except OSError:
                         time.sleep(1)
             else:
                 s = self.single_sockets.get(sock)
@@ -291,8 +294,8 @@ def handle_events(self, events):
                             self._close_socket(s)
                         else:
                             s.handler.data_came_in(s, data)
-                    except socket.error as e:
-                        if e[0] != EWOULDBLOCK:
+                    except OSError as e:
+                        if e.errno != EWOULDBLOCK:
                             self._close_socket(s)
                             continue
                 if event & POLLOUT and s.socket and not s.is_flushed():
@@ -335,12 +338,12 @@ def shutdown(self):
         for ss in list(self.single_sockets.values()):
             try:
                 ss.close()
-            except (AssertionError, KeyError, ValueError, socket.error):
+            except (AssertionError, KeyError, ValueError, OSError):
                 pass
         for server in self.servers.values():
             try:
                 server.close()
-            except socket.error:
+            except OSError:
                 pass
         if self.port_forwarded is not None:
             UPnP_close_port(self.port_forwarded)

BitTornado/Network/natpunch.py

@@ -186,7 +186,7 @@ def get_ip(self):
                         break
                 else:
                     raise ValueError('couldn\'t find intranet IP')
-            except (ValueError, socket.error):
+            except (ValueError, OSError):
                 self.local_ip = None
                 if DEBUG:
                     print('Error finding local IP')

BitTornado/Tracker/track.py

@@ -796,7 +796,8 @@ def params(key, default=None, l=paramslist):
                         l = self.becache[infohash]
                         y = not peer['left']
                         for x in l:
-                            del x[y][myid]
+                            if myid in x[y]:
+                                del x[y][myid]
                     if natted >= 0:
                         del peer['nat']     # restart NAT testing
                 if natted and natted < self.natcheck: