Merge lp:~cyli/divmod.org/remove-vertex into lp:divmod.org

[cyli]

Proposing to remove Vertex from the divmod repos. I found only one branch with a merge proposal for it:

https://code.launchpad.net/~alfred-54/divmod.org/divmod.org/+merge/158833

I've ported trunk as well as alfred-54's branch to https://github.com/cyli/vertex, which I will then transfer to the twistedmatrix organization after/if this branch is merged into divmod.org repo.

[Allen Short (washort)]

review: Approve

=== modified file 'Divmod.pth'
--- Divmod.pth	2013-01-02 10:08:46 +0000
+++ Divmod.pth	2013-06-27 06:07:28 +0000
@@ -1,4 +1,4 @@
-# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,vertex,hyperbola,imaginary,examplegame -*-
+# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,hyperbola,imaginary,examplegame -*-
 Axiom
 Combinator
 Epsilon
@@ -7,7 +7,6 @@
 Quotient
 Reverend
 Sine
-Vertex
 Hyperbola
 Imaginary
 Imaginary/ExampleGame
 
=== removed directory 'Vertex'
=== removed file 'Vertex/DEPS.txt'
--- Vertex/DEPS.txt	2006-06-14 11:54:41 +0000
+++ Vertex/DEPS.txt	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-Python 2.4
-Twisted 2.4.0
-PyOpenSSL 0.6
-OpenSSL 0.9.7
-Epsilon 0.5.0
 
=== removed file 'Vertex/LICENSE'
--- Vertex/LICENSE	2005-12-10 22:31:51 +0000
+++ Vertex/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright (c) 2005 Divmod Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 \ No newline at end of file
 
=== removed file 'Vertex/MANIFEST.in'
--- Vertex/MANIFEST.in	2006-06-14 11:54:41 +0000
+++ Vertex/MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-include LICENSE
-include NAME.txt
-include DEPS.txt
-include doc/q2q-standalone.tac
 
=== removed file 'Vertex/NAME.txt'
--- Vertex/NAME.txt	2005-08-27 23:09:07 +0000
+++ Vertex/NAME.txt	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-
-See: http://mathworld.wolfram.com/Vertex.html
-
-A vertex in mathematics is a location where two or more lines or edges meet.
-
-Divmod Vertex is an implementation of and interface to the Q2Q protocol.  It is
-named for a vertext because it provides a way for peers on the internet to
-establish connections with each other, e.g. to make their connection lines
-meet, regardless of intermediary interference such as network address
-translators and lack of naming information.
 
=== removed file 'Vertex/NEWS.txt'
--- Vertex/NEWS.txt	2009-11-30 01:08:55 +0000
+++ Vertex/NEWS.txt	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-0.3.0 (2009-11-25):
-  - Remove use of deprecated Twisted APIs from the test suite and improve
-    some error handling as a necessary consequence.
-  - Use twisted.internet.ssl instead of epsilon.sslverify.
-  - Remove an implementation of deferLater.
-
-0.2.0 (2006-06-12):
-  - Moved JUICE implementation into Epsilon.
-  - Removed dependency on Nevow's formless.
-  - Clarify licensing terms.
-  - Fix bugs on 64-bit platforms.
-  - removed buggy legacy non-TLS options which would break negotiation with
-    OpenSSL 0.9.8a.
-  - Deprecated twisted test APIs removed.
-  - First phase of integration with twisted.cred; vertex endpoints can now be
-    authenticated against a Twisted UsernamePassword cred authenticator.
-
-0.1.0 (2005-10-10):
-
-  - Initial release.
 
=== removed file 'Vertex/README.txt'
--- Vertex/README.txt	2006-06-14 11:54:41 +0000
+++ Vertex/README.txt	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-
-Divmod Vertex
-=============
-
-Divmod Vertex is the first implementation of the Q2Q protocol, which is a
-peer-to-peer communication protocol for establishing stream-based communication
-between named endpoints.
-
-It is also a P2P application client and server platform in the early stages of
-development.  It is currently quite usable for knocking holes in firewalls, but
-requires some polish to really be usable.
-
 
=== removed directory 'Vertex/bin'
=== removed file 'Vertex/bin/gvertex'
--- Vertex/bin/gvertex	2006-03-08 04:10:37 +0000
+++ Vertex/bin/gvertex	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-#!/usr/bin/python
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-from vertex.gtk2hack import main
-
-if __name__ == '__main__':
-    main()
 
=== removed file 'Vertex/bin/vertex'
--- Vertex/bin/vertex	2005-08-10 22:20:03 +0000
+++ Vertex/bin/vertex	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-#!/usr/bin/python
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-from vertex.q2qclient import Q2QClientProgram
-
-if __name__ == '__main__':
-    Q2QClientProgram().parseOptions()
 
=== removed directory 'Vertex/doc'
=== removed file 'Vertex/doc/notes'
--- Vertex/doc/notes	2005-08-05 03:13:02 +0000
+++ Vertex/doc/notes	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-
-Gin
-===
-
-TCP-alike over UDP
-
-Packet Format
-=============
-
-Connection ID - 32 bits
-Sequence Number - 32 bits
-Ack number - 32 bits
-Window - 32 bits
-Flags (SYN, ACK, FIN, IGN) - 8 bits
-Checksum - 32 bits
-Data length in bytes - 16 bits
-Data - See previous
-
-SEMANTICS
-=========
-Different types of packets:
-
-just SYN:
-SYN+ACK:
-just ACK: normal tcp packet meanings
-
-SYN+NAT: Request for information about the sender's public address
-
-ACK+NAT: Response with information about the recipient's public address.  The
-data is the IP address and port number to which the packet is being sent,
-formatted as a dotted-quad formatted IP address followed by a colon followed by
-the base-10 string representation of the port number..
-
-STB: Size Too Big - a packet with a dlen greater than the length of its data
-was received.
-
-Other Stuff:
-
-Connection IDs uniquely identify a stream for a protocol.  All bytes
-associated with a particular connectionID will be delivered to the
-same protocol instance.
-
-Sequence Numbers indicate the senders notion of how far into its
-outgoing stream this packet is.  Sequence numbers start from a
-pseudo-random value within the allowed range and are incremented by
-the number of bytes in each packet transmitted (re-transmits
-discounted).  This indicates to the peer where the bytes in each
-packet lie in the stream, allowing ordered delivery.
-
-Ack numbers indicate the senders notion of how far into its incoming
-stream all data has been received.  This value is always what the
-sender expects the receiver to use as its next sequence number.
-
-Window indicates the number of bytes in advance of the senders ack
-number the receiver may proceed in sending.  This receiver's sequence
-numbers must never be greater than the sender's last ack number plus
-their window number.
-
-Checksum is a CRC 32 of the data (and only the data - wait maybe this
-should be the header less the checksum, too, in case things get
-corrupted there)
 
=== removed file 'Vertex/doc/q2q-standalone.tac'
--- Vertex/doc/q2q-standalone.tac	2005-08-10 22:20:03 +0000
+++ Vertex/doc/q2q-standalone.tac	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-from vertex.q2qstandalone import defaultConfig
-
-application = defaultConfig()
-
 
=== removed directory 'Vertex/prime'
=== removed directory 'Vertex/prime/plugins'
=== removed file 'Vertex/prime/plugins/vertex_client.py'
--- Vertex/prime/plugins/vertex_client.py	2006-06-01 04:57:02 +0000
+++ Vertex/prime/plugins/vertex_client.py	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-
-from vertex.gtk2hack import PlugEntry
-
-pe = PlugEntry()
 
=== removed file 'Vertex/setup.py'
--- Vertex/setup.py	2009-11-30 01:08:55 +0000
+++ Vertex/setup.py	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-from epsilon import setuphelper
-
-from vertex import version
-
-setuphelper.autosetup(
-    name="Vertex",
-    version=version.short(),
-    maintainer="Divmod, Inc.",
-    maintainer_email="[e-mail]",
-    url="http://divmod.org/trac/wiki/DivmodVertex",
-    license="MIT",
-    platforms=["any"],
-    description=
-        """
-        Divmod Vertex is the first implementation of the Q2Q protocol, which
-        is a peer-to-peer communication protocol for establishing
-        stream-based communication between named endpoints.
-        """,
-    classifiers=[
-        "Development Status :: 2 - Pre-Alpha",
-        "Framework :: Twisted",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python",
-        "Topic :: Communications",
-        "Topic :: Internet",
-        "Topic :: Internet :: File Transfer Protocol (FTP)",
-        "Topic :: Internet :: Name Service (DNS)",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        ],
-    )
 
=== removed directory 'Vertex/vertex'
=== removed file 'Vertex/vertex/__init__.py'
--- Vertex/vertex/__init__.py	2008-08-11 11:19:59 +0000
+++ Vertex/vertex/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-# -*- test-case-name: vertex.test -*-
-
-from vertex._version import version
 
=== removed file 'Vertex/vertex/_version.py'
--- Vertex/vertex/_version.py	2009-11-30 01:08:55 +0000
+++ Vertex/vertex/_version.py	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-# This is an auto-generated file. Use admin/change-versions to update.
-from twisted.python import versions
-version = versions.Version(__name__[:__name__.rfind('.')], 0, 3, 0)
 
=== removed file 'Vertex/vertex/bits.py'
--- Vertex/vertex/bits.py	2005-08-05 06:02:56 +0000
+++ Vertex/vertex/bits.py	1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-# -*- test-case-name: vertex.test.test_bits -*-
-""" The purpose of this module is to provide the class BitArray, a compact
-overlay onto an array of bytes which is instead bit-addressable.  It also
-includes several bitwise operators.
-
-It does not include all array operations yet, most notably those related to
-slicing, since it is written primarily for use by the swarming implementation
-and swarming only requires fixed-size bit masks.
-
-"""
-
-__metaclass__ = type
-
-import array
-import operator
-import math
-
-BITS_PER_BYTE = 8
-
-def operate(operation):
-    # XXX TODO: optimize this and countbits later
-    def __x__(self, other):
-        if len(self) < len(other):
-            return operation(other, self)
-        new = BitArray(size=len(self))
-        for offt, (mybit, hisbit) in enumerate(zip(self, other)):
-            result = new[offt] = operation(mybit, hisbit)
-
-        for j in range(offt+1, len(self)):
-            new[j] = operation(self[j], 0)
-        return new
-    return __x__
-
-
-class BitArray:
-    """
-    A large mutable array of bits.
-    """
-
-    def __init__(self, bytes=None, size=None, default=0):
-        if bytes is None and size is None:
-            size = 0
-        if bytes is None:
-            bytes = array.array("B")
-            bytesize = int(math.ceil(float(size) / BITS_PER_BYTE))
-            if default:
-                padbyte = 255
-            else:
-                padbyte = 0
-            bytes.fromlist([padbyte] * bytesize)
-        self.bytes = bytes
-        if size is None:
-            size = len(self.bytes) * self.bytes.itemsize * BITS_PER_BYTE
-        self.size = size
-
-        # initialize 'on' and 'off' lists to optimize various things
-        self.on = []
-        self.off = []
-        blists = self.blists = self.off, self.on
-
-        for index, bit in enumerate(self):
-            blists[bit].append(index)
-
-    def append(self, bit):
-        offt = self.size
-        self.size += 1
-        if (len(self.bytes) * self.bytes.itemsize * BITS_PER_BYTE) < self.size:
-            self.bytes.append(0)
-        self[offt] = bit
-
-    def any(self, req=1):
-        return bool(self.blists[req])
-
-    def percent(self):
-        """
-        debugging method; returns a string indicating percentage completion
-        """
-        if not len(self):
-            return 'Inf%'
-        return '%0.2f%%'% ((float(self.countbits()) / len(self)) * 100,)
-
-    def __getitem__(self, bitcount):
-        if bitcount < 0:
-            bitcount += self.size
-        if bitcount >= self.size:
-            raise IndexError("%r >= %r" % (bitcount, self.size))
-        div, mod = divmod(bitcount, self.bytes.itemsize * BITS_PER_BYTE)
-        byte = self.bytes[div]
-        return (byte >> mod) & 1
-
-    def __setitem__(self, bitcount, bit):
-        if bitcount < 0:
-            bitcount += self.size
-        if bitcount >= self.size:
-            raise IndexError("bitcount too big")
-        div, mod = divmod(bitcount, self.bytes.itemsize * BITS_PER_BYTE)
-        if bit:
-            self.bytes[div] |= 1 << mod
-        else:
-            self.bytes[div] &= ~(1 << mod)
-
-        # change updating
-        notbitlist = self.blists[not bit]
-        try:
-            notbitlist.remove(bitcount)
-        except ValueError:
-            pass
-        bitlist = self.blists[bit]
-        if bitcount not in bitlist:
-            bitlist.append(bitcount)
-
-    def __len__(self):
-        return self.size
-
-    def __repr__(self):
-        l = []
-        l.append('[')
-        for b in self:
-            if b:
-                c = 'X'
-            else:
-                c = ' '
-            l.append(c)
-        l.append(']')
-        return ''.join(l)
-
-    def countbits(self, on=True):
-        return len(self.blists[on])
-
-    def positions(self, bit):
-        """
-        An iterator of all positions that a bit holds in this BitArray.
-
-        @param bit: 1 or 0
-        """
-        return self.blists[bit][:]
-
-    __xor__ = operate(operator.xor)
-    __and__ = operate(operator.and_)
-    __or__ = operate(operator.or_)
-
 
=== removed file 'Vertex/vertex/conncache.py'
--- Vertex/vertex/conncache.py	2009-07-06 11:40:18 +0000
+++ Vertex/vertex/conncache.py	1970-01-01 00:00:00 +0000
@@ -1,160 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-# -*- test-case-name: vertex.test.test_q2q.TCPConnection.testSendingFiles -*-
-
-"""
-Connect between two endpoints using a message-based protocol to exchange
-messages lazily in response to UI events, caching the protocol as necessary.
-Using connection-oriented protocols, you will most likely not want to use this
-class - you might end up retrieving a cached connection in the middle of a
-chunk of data being sent.  For the purposes of this distinction, a
-'message-oriented' protocol is one which has an API which either::
-
-  a) writes only whole messages to its transport so there is never an
-     opportunity to insert data into the middle of a message, or
-
-  b) provides an API on the Protocol instance for queuing whole messages such
-     that if partial messages are sent, calling the API multiple times will
-     queue them internally so that clients do not need to care whether the
-     connection is made or not.
-
-It is worth noting that all Juice-derived protocols meet constraint (b).
-"""
-
-from zope.interface import implements
-
-from twisted.internet.defer import maybeDeferred, DeferredList, Deferred
-from twisted.internet.main import CONNECTION_LOST
-from twisted.internet import interfaces
-from twisted.internet.protocol import ClientFactory
-
-
-class ConnectionCache:
-    def __init__(self):
-        """
-        """
-        # map (fromAddress, toAddress, protoName): protocol instance
-        self.cachedConnections = {}
-        # map (fromAddress, toAddress, protoName): list of Deferreds
-        self.inProgress = {}
-
-    def connectCached(self, endpoint, protocolFactory,
-                      extraWork=lambda x: x,
-                      extraHash=None):
-        """See module docstring
-        """
-        key = endpoint, extraHash
-        D = Deferred()
-        if key in self.cachedConnections:
-            D.callback(self.cachedConnections[key])
-        elif key in self.inProgress:
-            self.inProgress[key].append(D)
-        else:
-            self.inProgress[key] = [D]
-            endpoint.connect(
-                _CachingClientFactory(
-                    self, key, protocolFactory,
-                    extraWork))
-        return D
-
-    def cacheUnrequested(self, endpoint, extraHash, protocol):
-        self.connectionMadeForKey((endpoint, extraHash), protocol)
-
-    def connectionMadeForKey(self, key, protocol):
-        deferreds = self.inProgress.pop(key, [])
-        self.cachedConnections[key] = protocol
-        for d in deferreds:
-            d.callback(protocol)
-
-    def connectionLostForKey(self, key):
-        if key in self.cachedConnections:
-            del self.cachedConnections[key]
-
-    def connectionFailedForKey(self, key, reason):
-        deferreds = self.inProgress.pop(key)
-        for d in deferreds:
-            d.errback(reason)
-
-    def shutdown(self):
-        return DeferredList(
-            [maybeDeferred(p.transport.loseConnection)
-             for p in self.cachedConnections.values()])
-
-
-class _CachingClientFactory(ClientFactory):
-    debug = False
-
-    def __init__(self, cache, key, subFactory, extraWork):
-        """
-        @param cache: a Q2QService
-
-        @param key: a 2-tuple of (endpoint, extra) that represents what
-        connections coming from this factory are for.
-
-        @param subFactory: a ClientFactory which I forward methods to.
-
-        @param extraWork: extraWork(proto) -> Deferred which fires when the
-        connection has been prepared sufficiently to be used by subsequent
-        connections and can be counted as a success.
-        """
-
-        self.cache = cache
-        self.key = key
-        self.subFactory = subFactory
-        self.finishedExtraWork = False
-        self.extraWork = extraWork
-
-    lostAsFailReason = CONNECTION_LOST
-
-    def clientConnectionMade(self, protocol):
-        def success(reason):
-            self.cache.connectionMadeForKey(self.key, protocol)
-            self.finishedExtraWork = True
-            return protocol
-
-        def failed(reason):
-            self.lostAsFailReason = reason
-            protocol.transport.loseConnection()
-            return reason
-        maybeDeferred(self.extraWork, protocol).addCallbacks(
-            success, failed)
-
-    def clientConnectionLost(self, connector, reason):
-        if self.finishedExtraWork:
-            self.cache.connectionLostForKey(self.key)
-        else:
-            self.cache.connectionFailedForKey(self.key,
-                                              self.lostAsFailReason)
-        self.subFactory.clientConnectionLost(connector, reason)
-
-    def clientConnectionFailed(self, connector, reason):
-        self.cache.connectionFailedForKey(self.key, reason)
-        self.subFactory.clientConnectionFailed(connector, reason)
-
-    def buildProtocol(self, addr):
-        return _CachingTransportShim(self, self.subFactory.buildProtocol(addr))
-
-
-class _CachingTransportShim:
-    disconnecting = property(lambda self: self.transport.disconnecting)
-
-    implements(interfaces.IProtocol)
-
-    def __init__(self, factory, protocol):
-        self.factory = factory
-        self.protocol = protocol
-
-        # IProtocol
-        self.dataReceived = protocol.dataReceived
-        self.connectionLost = protocol.connectionLost
-
-
-    def makeConnection(self, transport):
-        self.transport = transport
-        self.protocol.makeConnection(transport)
-        self.factory.clientConnectionMade(self.protocol)
-
-
-    def __repr__(self):
-        return 'Q2Q-Cached<%r, %r>' % (self.transport,
-                                       self.protocol)
-
 
=== removed file 'Vertex/vertex/depserv.py'
--- Vertex/vertex/depserv.py	2009-07-06 11:40:18 +0000
+++ Vertex/vertex/depserv.py	1970-01-01 00:00:00 +0000
@@ -1,197 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-"""
-This module is no longer supported for use outside Vertex.
-"""
-
-from twisted.python import log
-from sets import Set
-from twisted.persisted import sob
-from twisted.application import service, internet
-
-from zope.interface import implements
-
-class Conf(dict):
-    """A class to help in construction the configuration for delpoy().
-
-    Typical usage::
-
-        from vertex.depserv import Conf
-        conf = Conf()
-        s = conf.section
-        s('pop',
-            port = 110,
-            sslPort = 995)
-        ...
-    """
-    def section(self, name, **kw):
-        self.setdefault(name, {}).update(kw)
-
-
-class NotPersistable:
-    implements(sob.IPersistable)
-    def __init__(self, original):
-        self.original = original
-
-    def setStyle(self, style):
-        self.style = style
-
-    def save(self, tag=None, filename=None, passphrase=None):
-        pass
-
-
-class StartupError(Exception):
-    pass
-
-
-class DependencyService(service.MultiService):
-    """A MultiService that can start multiple services with interdependencies.
-
-    Each keyword parameter is a dict which serves as the options for that
-    service.
-
-    Each service defines a method setup_SERVICE, which is called with the
-    matching parameters (the service name must be all caps). If there is no key
-    for SERVICE in the class parameters, the setup method is not called. The
-    return value is ignored, and DependencyService makes no assumptions about
-    any side effects.
-
-    Each service may also optionally define depends_SERVICE which is called
-    before the setup method with the same parameters as the setup method. This
-    method returns a list of names of services on which SERVICE depends.
-    DependencyService will then initialize the service is the correct order. If
-    circular dependencies result, or a service depends on another service which
-    does not exist or is not configured to run, StartupError is raised.
-
-    The class can define required services by setting 'requiredServices' to a
-    list of service names. These services will be initialized first in the
-    order they appear in the list, ignoring all dependency information. If
-    there are no parameters for a required service (consequently, the setup
-    method would not normally be called), StartupError is raised.
-    """
-
-
-    requiredServices = []
-
-
-    def __init__(self, **kw):
-        service.MultiService.__init__(self)
-
-        # this makes it possible for one service to change the configuration of
-        # another. Avoid if possible, there if you need it. Be sure to properly
-        # set the dependencies.
-        self.config = kw
-        self.servers = []
-
-        services = kw.keys()
-        initedServices = Set()
-        uninitedServices = Set(services)
-
-        # build dependencies
-        dependencies = {}
-        for serv in services:
-            try:
-                dependMethod = self._getDependsMethod(serv)
-            except AttributeError:
-                continue
-            dependencies[serv] = dependMethod(**kw[serv])
-
-        def initializeService(svc):
-            self._getServiceMethod(svc)(**kw[svc])
-            initedServices.add(svc)
-            uninitedServices.remove(svc)
-
-        for svc in self.requiredServices:
-            if dependencies.get(svc):
-                raise StartupError(
-                    '%r is a required service but has unsatisfied '
-                    'dependency on %r' % (svc, dependencies[svc]))
-            initializeService(svc)
-
-        while uninitedServices:
-            # iterate over the uninitialized services, adding those with no
-            # outstanding dependencies to initThisRound.
-            initThisRound = []
-            for serv in uninitedServices:
-                for dep in dependencies.get(serv, []):
-                    if dep not in initedServices:
-                        if dep not in uninitedServices:
-                            raise StartupError(
-                                'service %r depends on service %r, which is not '
-                                'configured or does not exist.' % (serv, dep))
-                        break
-                else:
-                    initThisRound.append(serv)
-            if not initThisRound:
-                raise StartupError(
-                    'Can not initialize all services. Circular dependencies '
-                    'between setup methods?')
-            for svc in initThisRound:
-                initializeService(svc)
-
-
-    def _getServiceMethod(self, service):
-        return getattr(self, 'setup_%s' % (service.upper(),))
-
-
-    def _getDependsMethod(self, service):
-        return getattr(self, 'depends_%s' % (service.upper(),))
-
-
-    def deploy(Class, name=None, uid=None, gid=None, **kw):
-        """Create an application with the give name, uid, and gid.
-
-        The application has one child service, an instance of Class
-        configured based on the additional keyword arguments passed.
-
-        The application is not persistable.
-        """
-        svc = Class(**kw)
-
-        if name is None:
-            name = Class.__name__
-        # Make it easier (possible) to find this service by name later on
-        svc.setName(name)
-
-        app = service.Application(name, uid=uid, gid=gid)
-        app.addComponent(NotPersistable(app), ignoreClass=True)
-        svc.setServiceParent(app)
-
-        return app
-    deploy = classmethod(deploy)
-
-    def attach(self, subservice):
-        subservice.setServiceParent(self)
-        return subservice
-
-    def detach(self, subservice):
-        subservice.disownServiceParent()
-
-    def addServer(self, normalPort, sslPort, f, name):
-        """Add a TCP and an SSL server. Name them `name` and `name`+'s'."""
-        tcp = internet.TCPServer(normalPort,f)
-        tcp.setName(name)
-        self.servers.append(tcp)
-        if sslPort is not None:
-            ssl = internet.SSLServer(sslPort, f, contextFactory=self.sslfac)
-            ssl.setName(name+'s')
-            self.servers.append(ssl)
-
-    def discernPrivilegedServers(self):
-        return [srv for srv in self.servers if srv.args[0] <= 1024]
-
-    def discernUnprivilegedServers(self):
-        return [srv for srv in self.servers if srv.args[0] > 1024]
-
-    def privilegedStartService(self):
-        for server in self.discernPrivilegedServers():
-            log.msg("privileged attach %r" % server)
-            self.attach(server)
-        return service.MultiService.privilegedStartService(self)
-
-    def startService(self):
-        for server in self.discernUnprivilegedServers():
-            log.msg("attaching %r" % server)
-            self.attach(server)
-
-        return service.MultiService.startService(self)
 
=== removed file 'Vertex/vertex/endpoint.py'
--- Vertex/vertex/endpoint.py	2005-08-05 06:02:56 +0000
+++ Vertex/vertex/endpoint.py	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-def stablesort(self, other):
-    return cmp(self.__class__, getattr(other, '__class__', type(other)))
-
-class TCPEndpoint:
-    def __init__(self, host, port):
-        self.host = host
-        self.port = port
-
-    def __hash__(self):
-        return hash((self.host, self.port)) + 5
-
-    def connect(self, protocolFactory):
-        from twisted.internet import reactor
-        return reactor.connectTCP(self.host, self.port, protocolFactory)
-
-    def __repr__(self):
-        return '<TCP@%s,%d>' % (self.host, self.port)
-
-    def __cmp__(self, other):
-        if isinstance(other, TCPEndpoint):
-            return cmp((self.host, self.port),
-                       (other.host, other.port))
-        return stablesort(self, other)
-
-
-class Q2QEndpoint:
-    def __init__(self, service, fromAddress, toAddress, protocolName):
-        self.service = service
-        self.fromAddress = fromAddress
-        self.toAddress = toAddress
-        self.protocolName = protocolName
-
-    def __repr__(self):
-        return '<Q2Q from <%s> to <%s> on %r>' % (
-            self.fromAddress, self.toAddress, self.protocolName)
-
-    def __cmp__(self, other):
-        if isinstance(other, Q2QEndpoint):
-            return cmp((self.fromAddress, self.toAddress, self.protocolName),
-                       (other.fromAddress, other.toAddress, other.protocolName))
-        return stablesort(self, other)
-
-    def __hash__(self):
-        return hash((self.fromAddress,
-                     self.toAddress,
-                     self.protocolName)) + 7
-
-    def connect(self, protocolFactory):
-        # from twisted.python.context import get
-        # get("q2q-service")
-        return self.service.connectQ2Q(
-            self.fromAddress, self.toAddress, self.protocolName,
-            protocolFactory)
-
 
=== removed file 'Vertex/vertex/gtk2hack.glade'
--- Vertex/vertex/gtk2hack.glade	2006-06-01 04:57:02 +0000
+++ Vertex/vertex/gtk2hack.glade	1970-01-01 00:00:00 +0000
@@ -1,635 +0,0 @@
-<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->
-<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.0.dtd">
-
-<glade-interface>
-<requires lib="gnome"/>
-
-<widget class="GtkMenu" id="notification_popup">
-
-  <child>
-    <widget class="GtkImageMenuItem" id="add_contact1">
-      <property name="visible">True</property>
-      <property name="label" translatable="yes">Add Contact</property>
-      <property name="use_underline">True</property>
-      <signal name="activate" handler="addContact" last_modification_time="Sun, 22 May 2005 01:24:07 GMT"/>
-
-      <child internal-child="image">
-	<widget class="GtkImage" id="image9">
-	  <property name="visible">True</property>
-	  <property name="stock">gtk-add</property>
-	  <property name="icon_size">1</property>
-	  <property name="xalign">0.5</property>
-	  <property name="yalign">0.5</property>
-	  <property name="xpad">0</property>
-	  <property name="ypad">0</property>
-	</widget>
-      </child>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkMenuItem" id="identifymenuitem">
-      <property name="visible">True</property>
-      <property name="label" translatable="yes">Identify</property>
-      <property name="use_underline">True</property>
-      <signal name="activate" handler="identifyDialog" last_modification_time="Sun, 22 May 2005 03:20:18 GMT"/>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkSeparatorMenuItem" id="contacts_begin">
-      <property name="visible">True</property>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkSeparatorMenuItem" id="separator3">
-      <property name="visible">True</property>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkMenuItem" id="animate">
-      <property name="visible">True</property>
-      <property name="label" translatable="yes">Animate</property>
-      <property name="use_underline">True</property>
-      <signal name="activate" handler="toggleAnimate" last_modification_time="Sun, 22 May 2005 01:44:10 GMT"/>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkSeparatorMenuItem" id="separator1">
-      <property name="visible">True</property>
-    </widget>
-  </child>
-
-  <child>
-    <widget class="GtkImageMenuItem" id="quit1">
-      <property name="visible">True</property>
-      <property name="stock_item">GNOMEUIINFO_MENU_EXIT_ITEM</property>
-      <signal name="activate" handler="quit" last_modification_time="Sun, 22 May 2005 01:24:07 GMT"/>
-    </widget>
-  </child>
-</widget>
-
-<widget class="GtkDialog" id="ident_dialog">
-  <property name="visible">True</property>
-  <property name="title" translatable="yes">Identify Yourself</property>
-  <property name="type">GTK_WINDOW_TOPLEVEL</property>
-  <property name="window_position">GTK_WIN_POS_CENTER</property>
-  <property name="modal">False</property>
-  <property name="resizable">False</property>
-  <property name="destroy_with_parent">False</property>
-  <property name="decorated">True</property>
-  <property name="skip_taskbar_hint">False</property>
-  <property name="skip_pager_hint">False</property>
-  <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
-  <property name="gravity">GDK_GRAVITY_NORTH_WEST</property>
-  <property name="focus_on_map">True</property>
-  <property name="urgency_hint">False</property>
-  <property name="has_separator">True</property>
-
-  <child internal-child="vbox">
-    <widget class="GtkVBox" id="dialog-vbox1">
-      <property name="visible">True</property>
-      <property name="homogeneous">False</property>
-      <property name="spacing">0</property>
-
-      <child internal-child="action_area">
-	<widget class="GtkHButtonBox" id="dialog-action_area1">
-	  <property name="visible">True</property>
-	  <property name="layout_style">GTK_BUTTONBOX_END</property>
-
-	  <child>
-	    <widget class="GtkButton" id="cancelbutton1">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-cancel</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-6</property>
-	      <signal name="clicked" handler="identifyCancel" last_modification_time="Sun, 22 May 2005 03:14:51 GMT"/>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkButton" id="okbutton1">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-ok</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-5</property>
-	      <signal name="clicked" handler="identifyOK" last_modification_time="Sun, 22 May 2005 03:15:00 GMT"/>
-	    </widget>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">True</property>
-	  <property name="pack_type">GTK_PACK_END</property>
-	</packing>
-      </child>
-
-      <child>
-	<widget class="GtkVBox" id="vbox1">
-	  <property name="visible">True</property>
-	  <property name="homogeneous">False</property>
-	  <property name="spacing">0</property>
-
-	  <child>
-	    <widget class="GtkTable" id="table1">
-	      <property name="border_width">5</property>
-	      <property name="visible">True</property>
-	      <property name="n_rows">2</property>
-	      <property name="n_columns">2</property>
-	      <property name="homogeneous">False</property>
-	      <property name="row_spacing">2</property>
-	      <property name="column_spacing">5</property>
-
-	      <child>
-		<widget class="GtkLabel" id="label4">
-		  <property name="visible">True</property>
-		  <property name="label" translatable="yes">Address</property>
-		  <property name="use_underline">False</property>
-		  <property name="use_markup">False</property>
-		  <property name="justify">GTK_JUSTIFY_LEFT</property>
-		  <property name="wrap">False</property>
-		  <property name="selectable">False</property>
-		  <property name="xalign">0</property>
-		  <property name="yalign">0.5</property>
-		  <property name="xpad">0</property>
-		  <property name="ypad">0</property>
-		  <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-		  <property name="width_chars">-1</property>
-		  <property name="single_line_mode">False</property>
-		  <property name="angle">0</property>
-		</widget>
-		<packing>
-		  <property name="left_attach">0</property>
-		  <property name="right_attach">1</property>
-		  <property name="top_attach">0</property>
-		  <property name="bottom_attach">1</property>
-		  <property name="x_options">fill</property>
-		  <property name="y_options"></property>
-		</packing>
-	      </child>
-
-	      <child>
-		<widget class="GtkLabel" id="label5">
-		  <property name="visible">True</property>
-		  <property name="label" translatable="yes">Password</property>
-		  <property name="use_underline">False</property>
-		  <property name="use_markup">False</property>
-		  <property name="justify">GTK_JUSTIFY_LEFT</property>
-		  <property name="wrap">False</property>
-		  <property name="selectable">False</property>
-		  <property name="xalign">0</property>
-		  <property name="yalign">0.5</property>
-		  <property name="xpad">0</property>
-		  <property name="ypad">0</property>
-		  <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-		  <property name="width_chars">-1</property>
-		  <property name="single_line_mode">False</property>
-		  <property name="angle">0</property>
-		</widget>
-		<packing>
-		  <property name="left_attach">0</property>
-		  <property name="right_attach">1</property>
-		  <property name="top_attach">1</property>
-		  <property name="bottom_attach">2</property>
-		  <property name="x_options">fill</property>
-		  <property name="y_options"></property>
-		</packing>
-	      </child>
-
-	      <child>
-		<widget class="GtkEntry" id="addressEntry">
-		  <property name="visible">True</property>
-		  <property name="can_focus">True</property>
-		  <property name="has_focus">True</property>
-		  <property name="editable">True</property>
-		  <property name="visibility">True</property>
-		  <property name="max_length">0</property>
-		  <property name="text" translatable="yes"></property>
-		  <property name="has_frame">True</property>
-		  <property name="invisible_char">*</property>
-		  <property name="activates_default">False</property>
-		</widget>
-		<packing>
-		  <property name="left_attach">1</property>
-		  <property name="right_attach">2</property>
-		  <property name="top_attach">0</property>
-		  <property name="bottom_attach">1</property>
-		  <property name="y_options"></property>
-		</packing>
-	      </child>
-
-	      <child>
-		<widget class="GtkEntry" id="passwordEntry">
-		  <property name="visible">True</property>
-		  <property name="can_focus">True</property>
-		  <property name="editable">True</property>
-		  <property name="visibility">False</property>
-		  <property name="max_length">0</property>
-		  <property name="text" translatable="yes"></property>
-		  <property name="has_frame">True</property>
-		  <property name="invisible_char">*</property>
-		  <property name="activates_default">True</property>
-		</widget>
-		<packing>
-		  <property name="left_attach">1</property>
-		  <property name="right_attach">2</property>
-		  <property name="top_attach">1</property>
-		  <property name="bottom_attach">2</property>
-		  <property name="y_options"></property>
-		</packing>
-	      </child>
-	    </widget>
-	    <packing>
-	      <property name="padding">0</property>
-	      <property name="expand">True</property>
-	      <property name="fill">True</property>
-	    </packing>
-	  </child>
-
-	  <child>
-	    <widget class="GtkProgressBar" id="identifyProgressBar">
-	      <property name="visible">True</property>
-	      <property name="orientation">GTK_PROGRESS_LEFT_TO_RIGHT</property>
-	      <property name="fraction">0</property>
-	      <property name="pulse_step">0.10000000149</property>
-	      <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-	    </widget>
-	    <packing>
-	      <property name="padding">0</property>
-	      <property name="expand">False</property>
-	      <property name="fill">False</property>
-	    </packing>
-	  </child>
-
-	  <child>
-	    <widget class="GtkLabel" id="identifyProgressLabel">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes"></property>
-	      <property name="use_underline">False</property>
-	      <property name="use_markup">False</property>
-	      <property name="justify">GTK_JUSTIFY_LEFT</property>
-	      <property name="wrap">False</property>
-	      <property name="selectable">False</property>
-	      <property name="xalign">0.5</property>
-	      <property name="yalign">0.5</property>
-	      <property name="xpad">0</property>
-	      <property name="ypad">0</property>
-	      <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-	      <property name="width_chars">-1</property>
-	      <property name="single_line_mode">False</property>
-	      <property name="angle">0</property>
-	    </widget>
-	    <packing>
-	      <property name="padding">3</property>
-	      <property name="expand">False</property>
-	      <property name="fill">False</property>
-	    </packing>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">True</property>
-	</packing>
-      </child>
-    </widget>
-  </child>
-</widget>
-
-<widget class="GtkDialog" id="add_contact_dialog">
-  <property name="visible">True</property>
-  <property name="title" translatable="yes">Add Contact</property>
-  <property name="type">GTK_WINDOW_TOPLEVEL</property>
-  <property name="window_position">GTK_WIN_POS_NONE</property>
-  <property name="modal">False</property>
-  <property name="resizable">True</property>
-  <property name="destroy_with_parent">False</property>
-  <property name="decorated">True</property>
-  <property name="skip_taskbar_hint">False</property>
-  <property name="skip_pager_hint">False</property>
-  <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
-  <property name="gravity">GDK_GRAVITY_NORTH_WEST</property>
-  <property name="focus_on_map">True</property>
-  <property name="urgency_hint">False</property>
-  <property name="has_separator">True</property>
-
-  <child internal-child="vbox">
-    <widget class="GtkVBox" id="dialog-vbox2">
-      <property name="visible">True</property>
-      <property name="homogeneous">False</property>
-      <property name="spacing">0</property>
-
-      <child internal-child="action_area">
-	<widget class="GtkHButtonBox" id="dialog-action_area2">
-	  <property name="visible">True</property>
-	  <property name="layout_style">GTK_BUTTONBOX_END</property>
-
-	  <child>
-	    <widget class="GtkButton" id="cancelbutton2">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-cancel</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-6</property>
-	      <signal name="activate" handler="popdownDialog" last_modification_time="Tue, 28 Feb 2006 09:34:42 GMT"/>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkButton" id="okbutton2">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-ok</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-5</property>
-	      <signal name="activate" handler="doAddContact" last_modification_time="Tue, 28 Feb 2006 09:34:23 GMT"/>
-	      <signal name="clicked" handler="doAddContact" last_modification_time="Tue, 28 Feb 2006 10:36:25 GMT"/>
-	    </widget>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">True</property>
-	  <property name="pack_type">GTK_PACK_END</property>
-	</packing>
-      </child>
-
-      <child>
-	<widget class="GtkFrame" id="frame1">
-	  <property name="visible">True</property>
-	  <property name="label_xalign">0</property>
-	  <property name="label_yalign">0.5</property>
-	  <property name="shadow_type">GTK_SHADOW_ETCHED_IN</property>
-
-	  <child>
-	    <widget class="GtkAlignment" id="alignment1">
-	      <property name="visible">True</property>
-	      <property name="xalign">0.5</property>
-	      <property name="yalign">0.5</property>
-	      <property name="xscale">1</property>
-	      <property name="yscale">1</property>
-	      <property name="top_padding">0</property>
-	      <property name="bottom_padding">0</property>
-	      <property name="left_padding">12</property>
-	      <property name="right_padding">0</property>
-
-	      <child>
-		<widget class="GtkTable" id="table2">
-		  <property name="border_width">16</property>
-		  <property name="visible">True</property>
-		  <property name="n_rows">2</property>
-		  <property name="n_columns">2</property>
-		  <property name="homogeneous">False</property>
-		  <property name="row_spacing">16</property>
-		  <property name="column_spacing">16</property>
-
-		  <child>
-		    <widget class="GtkEntry" id="nameentry">
-		      <property name="visible">True</property>
-		      <property name="can_focus">True</property>
-		      <property name="editable">True</property>
-		      <property name="visibility">True</property>
-		      <property name="max_length">0</property>
-		      <property name="text" translatable="yes"></property>
-		      <property name="has_frame">True</property>
-		      <property name="invisible_char">*</property>
-		      <property name="activates_default">False</property>
-		    </widget>
-		    <packing>
-		      <property name="left_attach">1</property>
-		      <property name="right_attach">2</property>
-		      <property name="top_attach">0</property>
-		      <property name="bottom_attach">1</property>
-		      <property name="y_options"></property>
-		    </packing>
-		  </child>
-
-		  <child>
-		    <widget class="GtkEntry" id="q2qidentry">
-		      <property name="visible">True</property>
-		      <property name="can_focus">True</property>
-		      <property name="editable">True</property>
-		      <property name="visibility">True</property>
-		      <property name="max_length">0</property>
-		      <property name="text" translatable="yes"></property>
-		      <property name="has_frame">True</property>
-		      <property name="invisible_char">*</property>
-		      <property name="activates_default">False</property>
-		    </widget>
-		    <packing>
-		      <property name="left_attach">1</property>
-		      <property name="right_attach">2</property>
-		      <property name="top_attach">1</property>
-		      <property name="bottom_attach">2</property>
-		      <property name="y_options"></property>
-		    </packing>
-		  </child>
-
-		  <child>
-		    <widget class="GtkLabel" id="label7">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">Name</property>
-		      <property name="use_underline">False</property>
-		      <property name="use_markup">False</property>
-		      <property name="justify">GTK_JUSTIFY_LEFT</property>
-		      <property name="wrap">False</property>
-		      <property name="selectable">False</property>
-		      <property name="xalign">0</property>
-		      <property name="yalign">0.5</property>
-		      <property name="xpad">0</property>
-		      <property name="ypad">0</property>
-		      <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-		      <property name="width_chars">-1</property>
-		      <property name="single_line_mode">False</property>
-		      <property name="angle">0</property>
-		    </widget>
-		    <packing>
-		      <property name="left_attach">0</property>
-		      <property name="right_attach">1</property>
-		      <property name="top_attach">0</property>
-		      <property name="bottom_attach">1</property>
-		      <property name="x_options">fill</property>
-		      <property name="y_options"></property>
-		    </packing>
-		  </child>
-
-		  <child>
-		    <widget class="GtkLabel" id="label8">
-		      <property name="visible">True</property>
-		      <property name="label" translatable="yes">Q2QID</property>
-		      <property name="use_underline">False</property>
-		      <property name="use_markup">False</property>
-		      <property name="justify">GTK_JUSTIFY_LEFT</property>
-		      <property name="wrap">False</property>
-		      <property name="selectable">False</property>
-		      <property name="xalign">0</property>
-		      <property name="yalign">0.5</property>
-		      <property name="xpad">0</property>
-		      <property name="ypad">0</property>
-		      <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-		      <property name="width_chars">-1</property>
-		      <property name="single_line_mode">False</property>
-		      <property name="angle">0</property>
-		    </widget>
-		    <packing>
-		      <property name="left_attach">0</property>
-		      <property name="right_attach">1</property>
-		      <property name="top_attach">1</property>
-		      <property name="bottom_attach">2</property>
-		      <property name="x_options">fill</property>
-		      <property name="y_options"></property>
-		    </packing>
-		  </child>
-		</widget>
-	      </child>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkLabel" id="label6">
-	      <property name="visible">True</property>
-	      <property name="label" translatable="yes">Contact Information</property>
-	      <property name="use_underline">False</property>
-	      <property name="use_markup">True</property>
-	      <property name="justify">GTK_JUSTIFY_LEFT</property>
-	      <property name="wrap">False</property>
-	      <property name="selectable">False</property>
-	      <property name="xalign">0.5</property>
-	      <property name="yalign">0.5</property>
-	      <property name="xpad">0</property>
-	      <property name="ypad">0</property>
-	      <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-	      <property name="width_chars">-1</property>
-	      <property name="single_line_mode">False</property>
-	      <property name="angle">0</property>
-	    </widget>
-	    <packing>
-	      <property name="type">label_item</property>
-	    </packing>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">True</property>
-	  <property name="fill">True</property>
-	</packing>
-      </child>
-    </widget>
-  </child>
-</widget>
-
-<widget class="GtkDialog" id="accept_connection_dialog">
-  <property name="visible">True</property>
-  <property name="title" translatable="yes">Accept Connection?</property>
-  <property name="type">GTK_WINDOW_TOPLEVEL</property>
-  <property name="window_position">GTK_WIN_POS_NONE</property>
-  <property name="modal">False</property>
-  <property name="resizable">True</property>
-  <property name="destroy_with_parent">False</property>
-  <property name="decorated">True</property>
-  <property name="skip_taskbar_hint">False</property>
-  <property name="skip_pager_hint">False</property>
-  <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
-  <property name="gravity">GDK_GRAVITY_NORTH_WEST</property>
-  <property name="focus_on_map">True</property>
-  <property name="urgency_hint">False</property>
-  <property name="has_separator">True</property>
-  <signal name="destroy" handler="rejectConnectionEvt" last_modification_time="Tue, 28 Feb 2006 10:00:37 GMT"/>
-
-  <child internal-child="vbox">
-    <widget class="GtkVBox" id="dialog-vbox3">
-      <property name="visible">True</property>
-      <property name="homogeneous">False</property>
-      <property name="spacing">0</property>
-
-      <child internal-child="action_area">
-	<widget class="GtkHButtonBox" id="dialog-action_area3">
-	  <property name="visible">True</property>
-	  <property name="layout_style">GTK_BUTTONBOX_END</property>
-
-	  <child>
-	    <widget class="GtkButton" id="cancelbutton3">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-cancel</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-6</property>
-	      <signal name="activate" handler="destroyit" last_modification_time="Tue, 28 Feb 2006 10:00:55 GMT"/>
-	      <signal name="clicked" handler="destroyit" last_modification_time="Tue, 28 Feb 2006 10:36:09 GMT"/>
-	    </widget>
-	  </child>
-
-	  <child>
-	    <widget class="GtkButton" id="okbutton3">
-	      <property name="visible">True</property>
-	      <property name="can_default">True</property>
-	      <property name="can_focus">True</property>
-	      <property name="label">gtk-ok</property>
-	      <property name="use_stock">True</property>
-	      <property name="relief">GTK_RELIEF_NORMAL</property>
-	      <property name="focus_on_click">True</property>
-	      <property name="response_id">-5</property>
-	      <signal name="activate" handler="acceptConnectionEvt" last_modification_time="Tue, 28 Feb 2006 09:59:48 GMT"/>
-	      <signal name="clicked" handler="acceptConnectionEvt" last_modification_time="Tue, 28 Feb 2006 10:36:51 GMT"/>
-	    </widget>
-	  </child>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">True</property>
-	  <property name="pack_type">GTK_PACK_END</property>
-	</packing>
-      </child>
-
-      <child>
-	<widget class="GtkLabel" id="accept_connection_label">
-	  <property name="visible">True</property>
-	  <property name="label" translatable="yes">Accept connection?</property>
-	  <property name="use_underline">False</property>
-	  <property name="use_markup">False</property>
-	  <property name="justify">GTK_JUSTIFY_LEFT</property>
-	  <property name="wrap">False</property>
-	  <property name="selectable">False</property>
-	  <property name="xalign">0.5</property>
-	  <property name="yalign">0.5</property>
-	  <property name="xpad">0</property>
-	  <property name="ypad">0</property>
-	  <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-	  <property name="width_chars">-1</property>
-	  <property name="single_line_mode">False</property>
-	  <property name="angle">0</property>
-	</widget>
-	<packing>
-	  <property name="padding">0</property>
-	  <property name="expand">False</property>
-	  <property name="fill">False</property>
-	</packing>
-      </child>
-    </widget>
-  </child>
-</widget>
-
-</glade-interface>
 
=== removed file 'Vertex/vertex/gtk2hack.py'
--- Vertex/vertex/gtk2hack.py	2006-06-01 04:57:02 +0000
+++ Vertex/vertex/gtk2hack.py	1970-01-01 00:00:00 +0000
@@ -1,270 +0,0 @@
-
-import os
-import rfc822
-
-from twisted.python.filepath import FilePath
-
-# import gtk ### pyflakes complains about this, due to the next line
-import gtk.glade
-
-from vertex.q2qclient import ClientQ2QService
-from vertex.q2q import Q2QAddress
-
-class _NullCb:
-    def __init__(self, name):
-        self.name = name
-
-    def __call__(self, *a, **kw):
-        print 'No callback provided for', self.name, a, kw
-
-class _SignalAttacher:
-    def __init__(self, original):
-        self.original = original
-
-    def __getitem__(self, callbackName):
-        return getattr(self.original, callbackName, None) or _NullCb(callbackName)
-
-GLADE_FILE = os.path.splitext(__file__)[0] + '.glade'
-
-class IdentificationDialog:
-    def __init__(self, clientService, plug):
-        self.xml = gtk.glade.XML(GLADE_FILE, "ident_dialog")
-        self.clientService = clientService
-        self.xml.signal_autoconnect(_SignalAttacher(self))
-        self.addressEntry = self.xml.get_widget('addressEntry')
-        self.passwordEntry = self.xml.get_widget('passwordEntry')
-        self.progressBar = self.xml.get_widget('identifyProgressBar')
-        self.progressLabel = self.xml.get_widget('identifyProgressLabel')
-        self.identifyWindow = self.xml.get_widget("ident_dialog")
-        self.cancelButton = self.xml.get_widget('cancelbutton1')
-        self.okButton = self.xml.get_widget('okbutton1')
-        self.plug = plug
-
-    def identifyCancel(self, event):
-        self.identifyWindow.destroy()
-
-    def identifyOK(self, event):
-        idstr = self.addressEntry.get_text()
-        D = self.clientService.authorize(
-            Q2QAddress.fromString(idstr),
-            self.passwordEntry.get_text())
-
-        sensitiveWidgets = [self.addressEntry,
-                            self.passwordEntry,
-                            self.okButton,
-                            self.cancelButton]
-        for widget in sensitiveWidgets:
-            widget.set_sensitive(False)
-        self.progressLabel.set_text("Authenticating...")
-        def itWorked(workedNone):
-            self.identifyWindow.destroy()
-            self.plug.setCurrentID(idstr)
-        def itDidntWork(error):
-            self.progressLabel.set_text(error.getErrorMessage())
-            for widget in sensitiveWidgets:
-                widget.set_sensitive(True)
-        D.addCallbacks(itWorked, itDidntWork)
-
-class AddContactDialog:
-    def __init__(self, plug):
-        self.xml = gtk.glade.XML(GLADE_FILE, "add_contact_dialog")
-        self.xml.signal_autoconnect(_SignalAttacher(self))
-        self.window = self.xml.get_widget("add_contact_dialog")
-        self.window.show_all()
-        self.plug = plug
-
-    def doAddContact(self, evt):
-        name = self.xml.get_widget("nameentry").get_text()
-        addr = self.xml.get_widget("q2qidentry").get_text()
-        self.plug.addBuddy(name, addr)
-        self.popdownDialog()
-
-    def popdownDialog(self, evt=None):
-        self.window.destroy()
-
-class AcceptConnectionDialog:
-    def __init__(self, d, From, to, protocol):
-        self.d = d
-        self.xml = gtk.glade.XML(GLADE_FILE, "accept_connection_dialog")
-        self.xml.signal_autoconnect(_SignalAttacher(self))
-        self.label = self.xml.get_widget("accept_connection_label")
-        self.label.set_text(
-            "Accept connection from %s for %s?" % (From, protocol))
-        self.window = self.xml.get_widget("accept_connection_dialog")
-        self.window.show_all()
-
-    done = False
-
-    def destroyit(self, evt):
-        self.window.destroy()
-
-    def acceptConnectionEvt(self, evt):
-        self.done = True
-        print "YES"
-        self.d.callback(1)
-        print "WHAT"
-        self.window.destroy()
-
-    def rejectConnectionEvt(self, evt):
-        print "DSTRY"
-        if not self.done:
-            print "DIE!"
-            from twisted.python import failure
-            self.d.errback(failure.Failure(KeyError("Connection rejected by user")))
-        else:
-            print "OK"
-
-from twisted.internet.protocol import ServerFactory
-from twisted.internet.protocol import Protocol
-
-class VertexDemoProtocol(Protocol):
-
-    def connectionMade(self):
-        print 'CONN MADE'
-
-    def dataReceived(self, data):
-        print 'HOLY SHNIKIES', data
-
-class VertexFactory(ServerFactory):
-    protocol = VertexDemoProtocol
-
-    def __init__(self, plug):
-        self.plug = plug
-
-    def startFactory(self):
-        #self.plug.animator.stop(1)
-        pass
-
-    def stopFactory(self):
-        #self.plug.animator.stop(0)
-        pass
-
-
-class BuddyItem:
-    def __init__(self, plug, alias, q2qaddress):
-        mi = self.menuItem = gtk.MenuItem(alias + " <"+q2qaddress+">")
-        mi.connect("activate", self.initiateFileTransfer)
-        mi.show_all()
-        self.plug = plug
-        self.alias = alias
-        self.q2qaddress = q2qaddress
-        self.plug.loadedBuddies[q2qaddress] = self
-
-    def initiateFileTransfer(self, evt):
-        print 'Initiate transfer with ' + self.alias + self.q2qaddress
-
-    def addToMenu(self):
-        self.plug.section.append(self.menuItem)
-
-    def removeFromMenu(self):
-        self.plug.section.remove(self.menuItem)
-
-from twisted.plugin import IPlugin
-from prime.iprime import IMenuApplication
-from zope.interface import implements
-
-class PlugEntry:
-    implements(IMenuApplication, IPlugin)
-
-    def __init__(self):
-        self.xml = gtk.glade.XML(GLADE_FILE, "notification_popup")
-
-    def register(self, section):
-        print 'REGISTER'
-        self.section = section
-
-        workingdir = FilePath(os.path.expanduser("~/.vertex"))
-        self.clientService = ClientQ2QService(
-            workingdir.child("q2q-certificates").path,
-            verifyHook=self.displayVerifyDialog,
-            inboundTCPPortnum=8172,
-            # q2qPortnum=8173,
-            udpEnabled=False)
-        self.setCurrentID(self.clientService.getDefaultFrom())
-        self.buddiesfile = workingdir.child("q2q-buddies.txt")
-        self.loadedBuddies = {}
-        self.parseBuddies()
-
-    def parseBuddies(self):
-        try:
-            self.buddyList = rfc822.AddressList(self.buddiesfile.open().read())
-        except IOError:
-            return
-        self.clearContactMenu()
-        for dispn, addr in self.buddyList:
-            if addr not in self.loadedBuddies:
-                BuddyItem(self, dispn, addr)
-        self.buildContactMenu()
-
-    def clearContactMenu(self):
-        for bud in self.loadedBuddies.values():
-            bud.removeFromMenu()
-
-    def buildContactMenu(self):
-        l = self.loadedBuddies.values()
-        l.sort(key=lambda x: x.alias)
-        l.reverse()
-        for bud in l:
-            bud.addToMenu()
-
-    def addBuddy(self, alias, q2qaddr):
-        temp = self.buddiesfile.temporarySibling()
-        try:
-            origdata = self.buddiesfile.open().read()
-        except IOError:
-            origdata = ''
-        moredata = '\n%s <%s>' % (alias, q2qaddr)
-        ftemp = temp.open('w')
-        ftemp.write(origdata)
-        ftemp.write(moredata)
-        ftemp.close()
-        temp.moveTo(self.buddiesfile)
-        self.parseBuddies()
-
-    def displayVerifyDialog(self, From, to, protocol):
-        from twisted.internet import defer
-        d = defer.Deferred()
-        AcceptConnectionDialog(d, From, to, protocol)
-        return d
-
-    def setCurrentID(self, idName):
-
-        if idName is not None:
-            currentID = Q2QAddress.fromString(idName)
-            # log in?
-            # self.animator.start()
-            SL = self.xml.get_widget("identifymenuitem").get_children()[0].set_label
-            def loggedIn(result):
-                SL(str(currentID))
-                self.currentID = currentID
-            def notLoggedIn(error):
-                SL("Identify")
-                # self.animator.stop(0)
-            # This following order is INSANE - you should definitely not have
-            # to wait until the LISTEN succeeds to start the service; quite the
-            # opposite, you should wait until the service has started, then
-            # issue the LISTEN!! For some reason, the connection drops
-            # immediately if you do that, and I have no idea why.  As soon as I
-            # can fix that issue the startService should be moved up previous
-            # to listenQ2Q.
-            self.clientService.listenQ2Q(currentID,
-                                         {'vertex': VertexFactory(self)},
-                                         "desktop vertex UI").addCallbacks(
-                loggedIn, notLoggedIn).addCallback(
-                lambda ign: self.clientService.startService())
-
-    # XXX event handlers
-
-    def toggleAnimate(self, event):
-        if self.animator.animating:
-            # SL("Animate")
-            self.animator.stop()
-        else:
-            # SL("Stop Animating")
-            self.animator.start()
-
-    def identifyDialog(self, event):
-        IdentificationDialog(self.clientService, self)
-
-    def addContact(self, event):
-        AddContactDialog(self)
 
=== removed file 'Vertex/vertex/icon-active.png'
 Binary files Vertex/vertex/icon-active.png	2006-06-01 04:57:02 +0000 and Vertex/vertex/icon-active.png	1970-01-01 00:00:00 +0000 differ
=== removed file 'Vertex/vertex/icon-inactive.png'
 Binary files Vertex/vertex/icon-inactive.png	2006-06-01 04:57:02 +0000 and Vertex/vertex/icon-inactive.png	1970-01-01 00:00:00 +0000 differ
=== removed file 'Vertex/vertex/ivertex.py'
--- Vertex/vertex/ivertex.py	2012-03-14 16:23:22 +0000
+++ Vertex/vertex/ivertex.py	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-from zope.interface import Interface
-
-class IQ2QTransport(Interface):
-    """
-    I am a byte-stream-oriented transport which has Q2Q identifiers associated
-    with the endpoints, and possibly some cryptographic verification of the
-    authenticity of those endpoints.
-    """
-
-    def getQ2QHost():
-        """ Returns a Q2QAddress object representing the user on this end of the
-        connection.
-        """
-
-    def getQ2QPeer():
-        """ Returns a Q2QAddress object representing the user on the other end of the
-        connection.
-        """
-
-class IQ2QUser(Interface):
-    """
-    A cred interface for Q2Q users.
-    """
-    def signCertificateRequest(certificateRequest, domainCert, suggestedSerial):
-        """
-        Return a signed certificate object if the subject fields in the
-        certificateRequest are valid.
-        """
-
-class IFileTransfer(Interface):
-
-    def getUploadSink(self, path):
-        """
-        @param path: a PathFragment that the client wishes to upload to.
-
-        @return: a DataSink where we'll save the data to.
-        """
-
-    def getDownloadSource(self, path):
-        """
-        @param path: a PathFragment that the client wishes to download.
-
-        @return: a DataSource to download data from.
-        """
-
-    def listChildren(self, path):
-        """
-        @param path: a PathFragment that the client wishes to get a list of.
-
-        @return: a list of dictionaries mapping::
-            {'name': str,
-             'size': int,
-             'type': vertex.filexfer.MIMEType,
-             'modified': datetime.datetime}
-        """
-
-class ISessionTokenStorage(Interface):
-    def idFromCookie(self, cookie, domain):
-        """Look up a user ID from the given cookie in the given domain.
-        """
-
-class ICertificateStorage(Interface):
-    def getSelfSignedCertificate(self, domainName):
-        """
-        @return: a Deferred which will fire with the certificate for the given
-        domain name.
-        """
-
-    def storeSelfSignedCertificate(self, domainName, mainCert):
-        """
-        @type mainCert: C{str}
-        @param mainCert: Serialized, self-signed certificate to associate
-        with the given domain.
-
-        @return: a Deferred which will fire when the certificate has been
-        stored successfully.
-        """
-
-    def getPrivateCertificate(self, domainName):
-        """
-        @return: a PrivateCertificate instance, e.g. a certificate including a
-        private key, for 'domainName'.
-        """
-
-    def addPrivateCertificate(self, domainName, existingCertificate=None):
-        """
-        """
-
-class IOfferUp(Interface):
-    """
-    Sharing control database storage.
-    """
-
-class IPlugin(Interface):
-    """
-    """
-
-class ITestPlugin(Interface):
-    """
-    Dummy plug-in interface for unit testing.
-    """
-
-class ITestPlugin2(Interface):
-    """
-    Dummy plug-in interface for unit testing.
-    """
 
=== removed file 'Vertex/vertex/ptcp.py'
--- Vertex/vertex/ptcp.py	2012-03-14 16:23:22 +0000
+++ Vertex/vertex/ptcp.py	1970-01-01 00:00:00 +0000
@@ -1,1050 +0,0 @@
-# -*- test-case-name: vertex.test.test_ptcp -*-
-
-import struct
-
-from binascii import crc32  # used to use zlib.crc32 - but that gives different
-                            # results on 64-bit platforms!!
-
-import itertools
-
-from twisted.python.failure import Failure
-from twisted.internet.defer import Deferred
-from twisted.internet import protocol, error, reactor, defer
-from twisted.internet.main import CONNECTION_DONE
-from twisted.python import log, util
-
-from vertex import tcpdfa
-from vertex.statemachine import StateError
-
-
-genConnID = itertools.count(8).next
-
-MAX_PSEUDO_PORT = (2 ** 16)
-
-_packetFormat = ('!' # WTF did you think
-                 'H' # sourcePseudoPort
-                 'H' # destPseudoPort
-                 'L' # sequenceNumber
-                 'L' # acknowledgementNumber
-                 'L' # window
-                 'B' # flags
-                 'l' # checksum
-                     # (signed because of binascii.crc32)
-                 'H' # dlen
-                 )
-_fixedSize = struct.calcsize(_packetFormat)
-
-_SYN, _ACK, _FIN, _RST, _STB = [1 << n for n in range(5)]
-
-def _flagprop(flag):
-    def setter(self, value):
-        if value:
-            self.flags |= flag
-        else:
-            self.flags &= ~flag
-    return property(lambda self: bool(self.flags & flag), setter)
-
-def relativeSequence(wireSequence, initialSequence, lapNumber):
-    """ Compute a relative sequence number from a wire sequence number so that we
-    can use natural Python comparisons on it, such as <, >, ==.
-
-    @param wireSequence: the sequence number received on the wire.
-
-    @param initialSequence: the ISN for this sequence, negotiated at SYN time.
-
-    @param lapNumber: the number of times that this value has wrapped around
-    2**32.
-    """
-    return (wireSequence + (lapNumber * (2**32))) - initialSequence
-
-class PTCPPacket(util.FancyStrMixin, object):
-    showAttributes = (
-        ('sourcePseudoPort', 'sourcePseudoPort', '%d'),
-        ('destPseudoPort', 'destPseudoPort', '%d'),
-        ('shortdata', 'data', '%r'),
-        ('niceflags', 'flags', '%s'),
-        ('dlen', 'dlen', '%d'),
-        ('seqNum', 'seq', '%d'),
-        ('ackNum', 'ack', '%d'),
-        ('checksum', 'checksum', '%x'),
-        ('peerAddressTuple', 'peerAddress', '%r'),
-        ('retransmitCount', 'retransmitCount', '%d'),
-        )
-
-    syn = _flagprop(_SYN)
-    ack = _flagprop(_ACK)
-    fin = _flagprop(_FIN)
-    rst = _flagprop(_RST)
-    stb = _flagprop(_STB)
-
-    # Number of retransmit attempts left for this segment.  When it reaches
-    # zero, this segment is dead.
-    retransmitCount = 50
-
-    def shortdata():
-        def get(self):
-            if len(self.data) > 13:
-                return self.data[:5] + '...' + self.data[-5:]
-            else:
-                return self.data
-        return get,
-    shortdata = property(*shortdata())
-
-    def niceflags():
-        def get(self):
-            res = []
-            for (f, v) in [
-                (self.syn, 'S'), (self.ack, 'A'), (self.fin, 'F'),
-                (self.rst, 'R'), (self.stb, 'T')]:
-                res.append(f and v or '.')
-            return ''.join(res)
-        return get,
-    niceflags = property(*niceflags())
-
-    def create(cls,
-               sourcePseudoPort, destPseudoPort,
-               seqNum, ackNum, data,
-               window=(1 << 15),
-               syn=False, ack=False, fin=False,
-               rst=False, stb=False,
-               destination=None):
-        i = cls(sourcePseudoPort, destPseudoPort,
-                seqNum, ackNum, window,
-                0, 0, len(data), data)
-        i.syn = syn
-        i.ack = ack
-        i.fin = fin
-        i.rst = rst
-        i.stb = stb
-        i.checksum = i.computeChecksum()
-        i.destination = destination
-        return i
-    create = classmethod(create)
-
-
-    def __init__(self,
-                 sourcePseudoPort,
-                 destPseudoPort,
-                 seqNum, ackNum, window, flags,
-                 checksum, dlen, data, peerAddressTuple=None,
-                 seqOffset=0, ackOffset=0, seqLaps=0, ackLaps=0):
-        self.sourcePseudoPort = sourcePseudoPort
-        self.destPseudoPort = destPseudoPort
-        self.seqNum = seqNum
-        self.ackNum = ackNum
-        self.window = window
-        self.flags = flags
-        self.checksum = checksum
-        self.dlen = dlen
-        self.data = data
-        self.peerAddressTuple = peerAddressTuple # None if local
-
-        self.seqOffset = seqOffset
-        self.ackOffset = ackOffset
-        self.seqLaps = seqLaps
-        self.ackLaps = ackLaps
-
-    def segmentLength(self):
-        """RFC page 26: 'The segment length (SEG.LEN) includes both data and sequence
-        space occupying controls'
-        """
-        return self.dlen + self.syn + self.fin
-
-    def relativeSeq(self):
-        return relativeSequence(self.seqNum, self.seqOffset, self.seqLaps)
-
-    def relativeAck(self):
-        return relativeSequence(self.ackNum, self.ackOffset, self.ackLaps)
-
-
-    def verifyChecksum(self):
-        if len(self.data) != self.dlen:
-            if len(self.data) > self.dlen:
-                raise GarbageDataError(self)
-            else:
-                raise TruncatedDataError(self)
-        expected = self.computeChecksum()
-        received = self.checksum
-        if expected != received:
-            raise ChecksumMismatchError(expected, received)
-
-    def computeChecksum(self):
-        return crc32(self.data)
-
-    def decode(cls, bytes, hostPortPair):
-        fields = struct.unpack(_packetFormat, bytes[:_fixedSize])
-        sourcePseudoPort, destPseudoPort, seq, ack, window, flags, checksum, dlen = fields
-        data = bytes[_fixedSize:]
-        pkt = cls(sourcePseudoPort, destPseudoPort, seq, ack, window, flags,
-                  checksum, dlen, data, hostPortPair)
-        return pkt
-    decode = classmethod(decode)
-
-    def mustRetransmit(self):
-        """Check to see if this packet must be retransmitted until it was received.
-        """
-        if self.syn or self.fin or self.dlen:
-            return True
-        return False
-
-    def encode(self):
-        dlen = len(self.data)
-        checksum = self.computeChecksum()
-        return struct.pack(
-            _packetFormat,
-            self.sourcePseudoPort, self.destPseudoPort,
-            self.seqNum, self.ackNum, self.window,
-            self.flags, checksum, dlen) + self.data
-
-    def fragment(self, mtu):
-        if self.dlen < mtu:
-            return [self]
-        assert not self.syn, "should not be originating syn packets w/ data"
-        seqOfft = 0
-        L = []
-        # XXX TODO: need to take seqLaps into account, etc.
-        for chunk in iterchunks(self.data, mtu):
-            last = self.create(self.sourcePseudoPort,
-                               self.destPseudoPort,
-                               self.seqNum + seqOfft,
-                               self.ackNum,
-                               chunk,
-                               self.window,
-                               destination=self.destination,
-                               ack=self.ack)
-            L.append(last)
-            seqOfft += len(chunk)
-        if self.fin:
-            last.fin = self.fin
-            last.checksum = last.computeChecksum()
-        return L
-
-
-def iterchunks(data, chunksize):
-    """iterate chunks of data
-    """
-    offt = 0
-    while offt < len(data):
-        yield data[offt:offt+chunksize]
-        offt += chunksize
-
-
-def ISN():
-    """
-    Initial Sequence Number generator.
-    """
-    # return int((time.time() * 1000000) / 4) % 2**32
-    return 0
-
-
-def segmentAcceptable(RCV_NXT, RCV_WND, SEG_SEQ, SEG_LEN):
-    # RFC page 26.
-    if SEG_LEN == 0 and RCV_WND == 0:
-        return SEG_SEQ == RCV_NXT
-    if SEG_LEN == 0 and RCV_WND > 0:
-        return ((RCV_NXT <= SEG_SEQ) and (SEG_SEQ < RCV_NXT + RCV_WND))
-    if SEG_LEN > 0 and RCV_WND == 0:
-        return False
-    if SEG_LEN > 0 and RCV_WND > 0:
-        return ((  (RCV_NXT <= SEG_SEQ) and (SEG_SEQ < RCV_NXT + RCV_WND))
-                or ((RCV_NXT <= SEG_SEQ+SEG_LEN-1) and
-                    (SEG_SEQ+SEG_LEN-1 < RCV_NXT + RCV_WND)))
-    assert 0, 'Should be impossible to get here.'
-    return False
-
-class BadPacketError(Exception):
-    """
-    A packet was bad for some reason.
-    """
-
-class ChecksumMismatchError(Exception):
-    """
-    The checksum and data received did not match.
-    """
-
-class TruncatedDataError(Exception):
-    """
-    The packet was truncated in transit, and all of the data did not arrive.
-    """
-
-class GarbageDataError(Exception):
-    """
-    Too much data was received (???)
-    """
-
-class PTCPConnection(tcpdfa.TCP):
-    """
-    Implementation of RFC 793 state machine.
-
-    @ivar oldestUnackedSendSeqNum: (TCP RFC: SND.UNA) The oldest (relative)
-    sequence number referring to an octet which we have sent or may send which
-    is unacknowledged.  This begins at 0, which is special because it is not
-    for an octet, but rather for the initial SYN packet.  Unless it is 0, this
-    represents the sequence number of self._outgoingBytes[0].
-
-    @ivar nextSendSeqNum: (TCP RFC: SND.NXT) The next (relative) sequence
-    number that we will send to our peer after the current buffered segments
-    have all been acknowledged.  This is the sequence number of the
-    not-yet-extant octet in the stream at
-    self._outgoingBytes[len(self._outgoingBytes)].
-
-    @ivar nextRecvSeqNum: (TCP RFC: RCV.NXT) The next (relative) sequence
-    number that the peer should send to us if they want to send more data;
-    their first unacknowledged sequence number as far as we are concerned; the
-    left or lower edge of the receive window; the sequence number of the first
-    octet that has not been delivered to the application.  changed whenever we
-    receive an appropriate ACK.
-
-    @ivar peerSendISN: the initial sequence number that the peer sent us during
-    the negotiation phase.  All peer-relative sequence numbers are computed
-    using this.  (see C{relativeSequence}).
-
-    @ivar hostSendISN: the initial sequence number that the we sent during the
-    negotiation phase.  All host-relative sequence numbers are computed using
-    this.  (see C{relativeSequence})
-
-    @ivar retransmissionQueue: a list of packets to be re-sent until their
-    acknowledgements come through.
-
-    @ivar recvWindow: (TCP RFC: RCV.WND) - the size [in octets] of the current
-    window allowed by this host, to be in transit from the other host.
-
-    @ivar sendWindow: (TCP RFC: SND.WND) - the size [in octets] of the current
-    window allowed by our peer, to be in transit from us.
-
-    """
-
-    mtu = 512 - _fixedSize
-
-    recvWindow = mtu
-    sendWindow = mtu
-    sendWindowRemaining = mtu * 2
-
-    protocol = None
-
-    def __init__(self,
-                 hostPseudoPort, peerPseudoPort,
-                 ptcp, factory, peerAddressTuple):
-        tcpdfa.TCP.__init__(self)
-        self.hostPseudoPort = hostPseudoPort
-        self.peerPseudoPort = peerPseudoPort
-        self.ptcp = ptcp
-        self.factory = factory
-        self._receiveBuffer = []
-        self.retransmissionQueue = []
-        self.peerAddressTuple = peerAddressTuple
-
-        self.oldestUnackedSendSeqNum = 0
-        self.nextSendSeqNum = 0
-        self.hostSendISN = 0
-        self.nextRecvSeqNum = 0
-        self.peerSendISN = 0
-        self.setPeerISN = False
-
-    peerSendISN = None
-
-    def packetReceived(self, packet):
-        # XXX TODO: probably have to do something to the packet here to
-        # identify its relative sequence number.
-
-        # print 'received', self, packet
-
-        if packet.stb:
-            # Shrink the MTU
-            [self.mtu] = struct.unpack('!H', packet.data)
-            rq = []
-            for pkt in self.retransmissionQueue:
-                rq.extend(pkt.fragment(self.mtu))
-            self.retransmissionQueue = rq
-            return
-
-        if self._paused:
-            return
-
-        generatedStateMachineInput = False
-        if packet.syn:
-            if packet.dlen:
-                # Whoops, what?  SYNs probably can contain data, I think, but I
-                # certainly don't see anything in the spec about how to deal
-                # with this or in ethereal for how linux deals with it -glyph
-                raise BadPacketError(
-                    "currently no data allowed in SYN packets: %r"
-                    % (packet,))
-            else:
-                assert packet.segmentLength() == 1
-            if self.peerAddressTuple is None:
-                # we're a server
-                assert self.wasEverListen, "Clients must specify a connect address."
-                self.peerAddressTuple = packet.peerAddressTuple
-            else:
-                # we're a client
-                assert self.peerAddressTuple == packet.peerAddressTuple
-            if self.setPeerISN:
-                if self.peerSendISN != packet.seqNum:
-                    raise BadPacketError(
-                        "Peer ISN was already set to %s but incoming packet "
-                        "tried to set it to %s" % (
-                            self.peerSendISN, packet.seqNum))
-                if not self.retransmissionQueue:
-                    # If our retransmissionQueue is hot, we are going to send
-                    # them an ACK to this with the next packet we send them
-                    # anyway; as a bonus, this will properly determine whether
-                    # we're sending a SYN+ACK or merely an ACK; the only time
-                    # we send an ACK is when we have nothing to say to them and
-                    # they're blocked on getting a response to their SYN+ACK
-                    # from us. -glyph
-                    self.originate(ack=True)
-                return
-            self.setPeerISN = True
-            self.peerSendISN = packet.seqNum
-            # syn, fin, and data are mutually exclusive, so this relative
-            # sequence-number increment is done both here, and below in the
-            # data/fin processing block.
-            self.nextRecvSeqNum += packet.segmentLength()
-            if not packet.ack:
-                generatedStateMachineInput = True
-                self.input(tcpdfa.SYN)
-
-        SEG_ACK = packet.relativeAck() # aliasing this for easier reading w/
-                                       # the RFC
-        if packet.ack:
-            if (self.oldestUnackedSendSeqNum < SEG_ACK and
-                SEG_ACK <= self.nextSendSeqNum):
-                # According to the spec, an 'acceptable ack
-                rq = self.retransmissionQueue
-                while rq:
-                    segmentOnQueue = rq[0]
-                    qSegSeq = segmentOnQueue.relativeSeq()
-                    if qSegSeq + segmentOnQueue.segmentLength() <= SEG_ACK:
-                        # fully acknowledged, as per RFC!
-                        rq.pop(0)
-                        sminput = None
-                        self.sendWindowRemaining += segmentOnQueue.segmentLength()
-                        # print 'inc send window', self, self.sendWindowRemaining
-                        if segmentOnQueue.syn:
-                            if packet.syn:
-                                sminput = tcpdfa.SYN_ACK
-                            else:
-                                sminput = tcpdfa.ACK
-                        elif segmentOnQueue.fin:
-                            sminput = tcpdfa.ACK
-                        if sminput is not None:
-                            # print 'ack input:', segmentOnQueue, packet, sminput
-                            generatedStateMachineInput = True
-                            self.input(sminput)
-                    else:
-                        break
-                else:
-                    # write buffer is empty; alert the application layer.
-                    self._writeBufferEmpty()
-                self.oldestUnackedSendSeqNum = SEG_ACK
-
-        if packet.syn:
-            assert generatedStateMachineInput
-            return
-
-        # XXX TODO: examine 'window' field and adjust sendWindowRemaining
-        # is it 'occupying a portion of valid receive sequence space'?  I think
-        # this means 'packet which might acceptably contain useful data'
-        if not packet.segmentLength():
-            assert packet.ack, "What the _HELL_ is wrong with this packet:" +str(packet)
-            return
-
-        if not segmentAcceptable(self.nextRecvSeqNum,
-                                 self.recvWindow,
-                                 packet.relativeSeq(),
-                                 packet.segmentLength()):
-            # We have to transmit an ack here since it's old data.  We probably
-            # need to ack in more states than just ESTABLISHED... but which
-            # ones?
-            if not self.retransmissionQueue:
-                self.originate(ack=True)
-            return
-
-        # OK!  It's acceptable!  Let's process the various bits of data.
-        # Where is the useful data in the packet?
-        if packet.relativeSeq() > self.nextRecvSeqNum:
-            # XXX: Here's what's going on.  Data can be 'in the window', but
-            # still in the future.  For example, if I have a window of length 3
-            # and I send segments DATA1(len 1) DATA2(len 1) FIN and you receive
-            # them in the order FIN DATA1 DATA2, you don't actually want to
-            # process the FIN until you've processed the data.
-
-            # For the moment we are just dropping anything that isn't exactly
-            # the next thing we want to process.  This is perfectly valid;
-            # these packets might have been dropped, so the other end will have
-            # to retransmit them anyway.
-            return
-
-        if packet.dlen:
-            assert not packet.syn, 'no seriously I _do not_ know how to handle this'
-            usefulData = packet.data[self.nextRecvSeqNum - packet.relativeSeq():]
-            # DONT check/slice the window size here, the acceptability code
-            # checked it, we can over-ack if the other side is buggy (???)
-            if self.protocol is not None:
-                try:
-                    self.protocol.dataReceived(usefulData)
-                except:
-                    log.err()
-                    self.loseConnection()
-
-        self.nextRecvSeqNum += packet.segmentLength()
-        if self.state == tcpdfa.ESTABLISHED:
-            # In all other states, the state machine takes care of sending ACKs
-            # in its output process.
-            self.originate(ack=True)
-
-        if packet.fin:
-            self.input(tcpdfa.FIN)
-
-
-    def getHost(self):
-        tupl = self.ptcp.transport.getHost()
-        return PTCPAddress((tupl.host, tupl.port),
-                           self.pseudoPortPair)
-
-    def getPeer(self):
-        return PTCPAddress(self.peerAddressTuple,
-                           self.pseudoPortPair)
-
-    _outgoingBytes = ''
-    _nagle = None
-
-    def write(self, bytes):
-        assert not self.disconnected, 'Writing to a transport that was already disconnected.'
-        self._outgoingBytes += bytes
-        self._writeLater()
-
-
-    def writeSequence(self, seq):
-        self.write(''.join(seq))
-
-
-    def _writeLater(self):
-        if self._nagle is None:
-            self._nagle = reactor.callLater(0.001, self._reallyWrite)
-
-    def _originateOneData(self):
-        amount = min(self.sendWindowRemaining, self.mtu)
-        sendOut = self._outgoingBytes[:amount]
-        # print 'originating data packet', len(sendOut)
-        self._outgoingBytes = self._outgoingBytes[amount:]
-        self.sendWindowRemaining -= len(sendOut)
-        self.originate(ack=True, data=sendOut)
-
-    def _reallyWrite(self):
-        # print self, 'really writing', self._paused
-        self._nagle = None
-        if self._outgoingBytes:
-            # print 'window and bytes', self.sendWindowRemaining, len(self._outgoingBytes)
-            while self.sendWindowRemaining and self._outgoingBytes:
-                self._originateOneData()
-
-    _retransmitter = None
-    _retransmitTimeout = 0.5
-
-    def _retransmitLater(self):
-        assert self.state != tcpdfa.CLOSED
-        if self._retransmitter is None:
-            self._retransmitter = reactor.callLater(self._retransmitTimeout, self._reallyRetransmit)
-
-    def _stopRetransmitting(self):
-        # used both as a quick-and-dirty test shutdown hack and a way to shut
-        # down when we die...
-        if self._retransmitter is not None:
-            self._retransmitter.cancel()
-            self._retransmitter = None
-        if self._nagle is not None:
-            self._nagle.cancel()
-            self._nagle = None
-        if self._closeWaitLoseConnection is not None:
-            self._closeWaitLoseConnection.cancel()
-            self._closeWaitLoseConnection = None
-
-    def _reallyRetransmit(self):
-        # XXX TODO: packet fragmentation & coalescing.
-        # print 'Wee a retransmit!  What I got?', self.retransmissionQueue
-        self._retransmitter = None
-        if self.retransmissionQueue:
-            for packet in self.retransmissionQueue:
-                packet.retransmitCount -= 1
-                if packet.retransmitCount:
-                    packet.ackNum = self.currentAckNum()
-                    self.ptcp.sendPacket(packet)
-                else:
-                    self.input(tcpdfa.TIMEOUT)
-                    return
-            self._retransmitLater()
-
-    disconnecting = False       # This is *TWISTED* level state-machine stuff,
-                                # not TCP-level.
-
-    def loseConnection(self):
-        if not self.disconnecting:
-            self.disconnecting = True
-            if not self._outgoingBytes:
-                self._writeBufferEmpty()
-
-
-    def _writeBufferEmpty(self):
-        if self._outgoingBytes:
-            self._reallyWrite()
-        elif self.producer is not None:
-            if (not self.streamingProducer) or self.producerPaused:
-                self.producerPaused = False
-                self.producer.resumeProducing()
-        elif self.disconnecting and (not self.disconnected
-                                     or self.state == tcpdfa.CLOSE_WAIT):
-            self.input(tcpdfa.APP_CLOSE)
-
-
-    def _writeBufferFull(self):
-        # print 'my write buffer is full'
-        if (self.producer is not None
-            and not self.producerPaused):
-            self.producerPaused = True
-            # print 'producer pausing'
-            self.producer.pauseProducing()
-            # print 'producer paused'
-        else:
-            # print 'but I am not telling my producer to pause!'
-            # print '  ', self.producer, self.streamingProducer, self.producerPaused
-            pass
-
-
-    disconnected = False
-    producer = None
-    producerPaused = False
-    streamingProducer = False
-
-    def registerProducer(self, producer, streaming):
-        if self.producer is not None:
-            raise RuntimeError(
-                "Cannot register producer %s, "
-                "because producer %s was never unregistered."
-                % (producer, self.producer))
-        if self.disconnected:
-            producer.stopProducing()
-        else:
-            self.producer = producer
-            self.streamingProducer = streaming
-            if not streaming and not self._outgoingBytes:
-                producer.resumeProducing()
-
-    def unregisterProducer(self):
-        self.producer = None
-        if not self._outgoingBytes:
-            self._writeBufferEmpty()
-
-    _paused = False
-    def pauseProducing(self):
-        self._paused = True
-
-    def resumeProducing(self):
-        self._paused = False
-
-    def currentAckNum(self):
-        return (self.nextRecvSeqNum + self.peerSendISN) % (2**32)
-
-    def originate(self, data='', syn=False, ack=False, fin=False):
-        if syn:
-            # We really should be randomizing the ISN but until we finish the
-            # implementations of the various bits of wraparound logic that were
-            # started with relativeSequence
-            assert self.nextSendSeqNum == 0
-            assert self.hostSendISN == 0
-        p = PTCPPacket.create(self.hostPseudoPort,
-                              self.peerPseudoPort,
-                              seqNum=(self.nextSendSeqNum + self.hostSendISN) % (2**32),
-                              ackNum=self.currentAckNum(),
-                              data=data,
-                              window=self.recvWindow,
-                              syn=syn, ack=ack, fin=fin,
-                              destination=self.peerAddressTuple)
-        # do we want to enqueue this packet for retransmission?
-        sl = p.segmentLength()
-        self.nextSendSeqNum += sl
-
-        if p.mustRetransmit():
-            # print self, 'originating retransmittable packet', len(self.retransmissionQueue)
-            if self.retransmissionQueue:
-                if self.retransmissionQueue[-1].fin:
-                    raise AssertionError("Sending %r after FIN??!" % (p,))
-            # print 'putting it on the queue'
-            self.retransmissionQueue.append(p)
-            # print 'and sending it later'
-            self._retransmitLater()
-            if not self.sendWindowRemaining: # len(self.retransmissionQueue) > 5:
-                # print 'oh no my queue is too big'
-                # This is a random number (5) because I ought to be summing the
-                # packet lengths or something.
-                self._writeBufferFull()
-            else:
-                # print 'my queue is still small enough', len(self.retransmissionQueue), self, self.sendWindowRemaining
-                pass
-        self.ptcp.sendPacket(p)
-
-    # State machine transition definitions, hooray.
-    def transition_SYN_SENT_to_CLOSED(self):
-        """
-        The connection never got anywhere.  Goodbye.
-        """
-        # XXX CONNECTOR API OMFG
-        self.factory.clientConnectionFailed(None, error.TimeoutError())
-
-
-    wasEverListen = False
-
-    def enter_LISTEN(self):
-        # Spec says this is necessary for RST handling; we need it for making
-        # sure it's OK to bind port numbers.
-        self.wasEverListen = True
-
-    def enter_CLOSED(self):
-        self.ptcp.connectionClosed(self)
-        self._stopRetransmitting()
-        if self._timeWaitCall is not None:
-            self._timeWaitCall.cancel()
-            self._timeWaitCall = None
-
-    _timeWaitCall = None
-    _timeWaitTimeout = 0.01     # REALLY fast timeout, right now this is for
-                                # the tests...
-
-    def enter_TIME_WAIT(self):
-        self._stopRetransmitting()
-        self._timeWaitCall = reactor.callLater(self._timeWaitTimeout, self._do2mslTimeout)
-
-    def _do2mslTimeout(self):
-        self._timeWaitCall = None
-        self.input(tcpdfa.TIMEOUT)
-
-    peerAddressTuple = None
-
-    def transition_LISTEN_to_SYN_SENT(self):
-        """
-        Uh, what?  We were listening and we tried to send some bytes.
-        This is an error for PTCP.
-        """
-        raise StateError("You can't write anything until someone connects to you.")
-
-#     def invalidInput(self, datum):
-#         print self, self.protocol, 'invalid input', datum
-
-    def pseudoPortPair():
-        def get(self):
-            return (self.hostPseudoPort,
-                    self.peerPseudoPort)
-        return get,
-    pseudoPortPair = property(*pseudoPortPair())
-
-    def enter_ESTABLISHED(self):
-        """
-        We sent out SYN, they acknowledged it.  Congratulations, you
-        have a new baby connection.
-        """
-        assert not self.disconnecting
-        assert not self.disconnected
-        try:
-            p = self.factory.buildProtocol(PTCPAddress(
-                    self.peerAddressTuple, self.pseudoPortPair))
-            p.makeConnection(self)
-        except:
-            log.msg("Exception during PTCP connection setup.")
-            log.err()
-            self.loseConnection()
-        else:
-            self.protocol = p
-
-    def exit_ESTABLISHED(self):
-        assert not self.disconnected
-        self.disconnected = True
-        try:
-            self.protocol.connectionLost(Failure(CONNECTION_DONE))
-        except:
-            log.err()
-        self.protocol = None
-
-        if self.producer is not None:
-            try:
-                self.producer.stopProducing()
-            except:
-                log.err()
-            self.producer = None
-
-
-    _closeWaitLoseConnection = None
-
-    def enter_CLOSE_WAIT(self):
-        # Twisted automatically reacts to network half-close by issuing a full
-        # close.
-        self._closeWaitLoseConnection = reactor.callLater(0.01, self._loseConnectionBecauseOfCloseWait)
-
-    def _loseConnectionBecauseOfCloseWait(self):
-        self._closeWaitLoseConnection = None
-        self.loseConnection()
-
-    def immediateShutdown(self):
-        """_IMMEDIATELY_ shut down this connection, sending one (non-retransmitted)
-        app-close packet, emptying our buffers, clearing our producer and
-        getting ready to die right after this call.
-        """
-        self._outgoingBytes = ''
-        if self.state == tcpdfa.ESTABLISHED:
-            self.input(tcpdfa.APP_CLOSE)
-            self._stopRetransmitting()
-            self._reallyRetransmit()
-
-        # All states that we can reasonably be in handle a timeout; force our
-        # connection to think that it's become desynchronized with the other
-        # end so that it will totally shut itself down.
-
-        self.input(tcpdfa.TIMEOUT)
-        assert self._retransmitter is None
-        assert self._nagle is None
-
-    def output_ACK(self):
-        self.originate(ack=True)
-
-    def output_FIN(self):
-        self.originate(fin=True)
-
-    def output_SYN_ACK(self):
-        self.originate(syn=True, ack=True)
-
-    def output_SYN(self):
-        self.originate(syn=True)
-
-class PTCPAddress(object):
-    # garbage
-
-    def __init__(self, (host, port), (pseudoHostPort, pseudoPeerPort)):
-        self.host = host
-        self.port = port
-        self.pseudoHostPort = pseudoHostPort
-        self.pseudoPeerPort = pseudoPeerPort
-
-    def __repr__(self):
-        return 'PTCPAddress((%r, %r), (%r, %r))' % (
-            self.host, self.port,
-            self.pseudoHostPort,
-            self.pseudoPeerPort)
-
-
-
-class _PendingEvent(object):
-    def __init__(self):
-        self.listeners = []
-
-
-    def deferred(self):
-        d = Deferred()
-        self.listeners.append(d)
-        return d
-
-
-    def callback(self, result):
-        l = self.listeners
-        self.listeners = []
-        for d in l:
-            d.callback(result)
-
-
-    def errback(self, result=None):
-        if result is None:
-            result = Failure()
-        l = self.listeners
-        self.listeners = []
-        for d in l:
-            d.errback(result)
-
-
-
-class PTCP(protocol.DatagramProtocol):
-    """
-    L{PTCP} implements a strongly TCP-like protocol on top of UDP.  It
-    provides a transport which is connection-oriented, streaming,
-    ordered, and reliable.
-
-    @ivar factory: A L{ServerFactory} which is used to create
-        L{IProtocol} providers whenever a new PTCP connection is made
-        to this port.
-
-    @ivar _connections: A mapping of endpoint addresses to connection
-        objects.  These are the active connections being multiplexed
-        over this UDP port.  Many PTCP connections may run over the
-        same L{PTCP} instance, communicating with many different
-        remote hosts as well as multiplexing different PTCP
-        connections to the same remote host.  The mapping keys,
-        endpoint addresses, are three-tuples of:
-
-            - The destination pseudo-port which is always C{1}
-            - The source pseudo-port
-            - A (host, port) tuple giving the UDP address of a PTCP
-              peer holding the other side of the connection
-
-        The mapping values, connection objects, are L{PTCPConnection}
-        instances.
-    @type _connections: C{dict}
-
-    """
-    # External API
-
-    def __init__(self, factory):
-        self.factory = factory
-        self._allConnectionsClosed = _PendingEvent()
-
-
-    def connect(self, factory, host, port, pseudoPort=1):
-        """
-        Attempt to establish a new connection via PTCP to the given
-        remote address.
-
-        @param factory: A L{ClientFactory} which will be used to
-            create an L{IProtocol} provider if the connection is
-            successfully set up, or which will have failure callbacks
-            invoked on it otherwise.
-
-        @param host: The IP address of another listening PTCP port to
-            connect to.
-        @type host: C{str}
-
-        @param port: The port number of that other listening PTCP port
-            to connect to.
-        @type port: C{int}
-
-        @param pseudoPort: Not really implemented.  Do not pass a
-            value for this parameter or things will break.
-
-        @return: A L{PTCPConnection} instance representing the new
-            connection, but you really shouldn't use this for
-            anything.  Write a protocol!
-        """
-        sourcePseudoPort = genConnID() % MAX_PSEUDO_PORT
-        conn = self._connections[(pseudoPort, sourcePseudoPort, (host, port))
-                                 ] = PTCPConnection(
-            sourcePseudoPort, pseudoPort, self, factory, (host, port))
-        conn.input(tcpdfa.APP_ACTIVE_OPEN)
-        return conn
-
-    def sendPacket(self, packet):
-        if self.transportGoneAway:
-            return
-        self.transport.write(packet.encode(), packet.destination)
-
-
-    # Internal stuff
-    def startProtocol(self):
-        self.transportGoneAway = False
-        self._lastConnID = 10 # random.randrange(2 ** 32)
-        self._connections = {}
-
-    def _finalCleanup(self):
-        """
-        Clean up all of our connections by issuing application-level close and
-        stop notifications, sending hail-mary final FIN packets (which may not
-        reach the other end, but nevertheless can be useful) when possible.
-        """
-        for conn in self._connections.values():
-            conn.immediateShutdown()
-        assert not self._connections
-
-    def stopProtocol(self):
-        """
-        Notification from twisted that our underlying port has gone away;
-        make sure we're not going to try to send any packets through our
-        transport and blow up, then shut down all of our protocols, issuing
-        appr
-        opriate application-level messages.
-        """
-        self.transportGoneAway = True
-        self._finalCleanup()
-
-    def cleanupAndClose(self):
-        """
-        Clean up all remaining connections, then close our transport.
-
-        Although in a pinch we will do cleanup after our socket has gone away
-        (if it does so unexpectedly, above in stopProtocol), we would really
-        prefer to do cleanup while we still have access to a transport, since
-        that way we can force out a few final packets and save the remote
-        application an awkward timeout (if it happens to get through, which
-        is generally likely).
-        """
-        self._finalCleanup()
-        return self._stop()
-
-    def datagramReceived(self, bytes, addr):
-        if len(bytes) < _fixedSize:
-            # It can't be any good.
-            return
-
-        pkt = PTCPPacket.decode(bytes, addr)
-        try:
-            pkt.verifyChecksum()
-        except TruncatedDataError:
-#             print '(ptcp packet truncated: %r)' % (pkt,)
-            self.sendPacket(
-                PTCPPacket.create(
-                    pkt.destPseudoPort,
-                    pkt.sourcePseudoPort,
-                    0,
-                    0,
-                    struct.pack('!H', len(pkt.data)),
-                    stb=True,
-                    destination=addr))
-        except GarbageDataError:
-            print "garbage data!", pkt
-        except ChecksumMismatchError, cme:
-            print "bad checksum", pkt, cme
-            print repr(pkt.data)
-            print hex(pkt.checksum), hex(pkt.computeChecksum())
-        else:
-            self.packetReceived(pkt)
-
-    stopped = False
-    def _stop(self, result=None):
-        if not self.stopped:
-            self.stopped = True
-            return self.transport.stopListening()
-        else:
-            return defer.succeed(None)
-
-    def waitForAllConnectionsToClose(self):
-        """
-        Wait for all currently-open connections to enter the 'CLOSED' state.
-        Currently this is only usable from test fixtures.
-        """
-        if not self._connections:
-            return self._stop()
-        return self._allConnectionsClosed.deferred().addBoth(self._stop)
-
-    def connectionClosed(self, ptcpConn):
-        packey = (ptcpConn.peerPseudoPort, ptcpConn.hostPseudoPort,
-                  ptcpConn.peerAddressTuple)
-        del self._connections[packey]
-        if ((not self.transportGoneAway) and
-            (not self._connections) and
-            self.factory is None):
-            self._stop()
-        if not self._connections:
-            self._allConnectionsClosed.callback(None)
-
-    def packetReceived(self, packet):
-        packey = (packet.sourcePseudoPort, packet.destPseudoPort, packet.peerAddressTuple)
-        if packey not in self._connections:
-            if packet.flags == _SYN and packet.destPseudoPort == 1: # SYN and _ONLY_ SYN set.
-                conn = PTCPConnection(packet.destPseudoPort,
-                                      packet.sourcePseudoPort, self,
-                                      self.factory, packet.peerAddressTuple)
-                conn.input(tcpdfa.APP_PASSIVE_OPEN)
-                self._connections[packey] = conn
-            else:
-                log.msg("corrupted packet? %r %r %r" % (packet,packey, self._connections))
-                return
-        try:
-            self._connections[packey].packetReceived(packet)
-        except:
-            log.msg("PTCPConnection error on %r:" % (packet,))
-            log.err()
-            del self._connections[packey]
 
=== removed file 'Vertex/vertex/q2q.py'
--- Vertex/vertex/q2q.py	2012-03-14 23:42:53 +0000
+++ Vertex/vertex/q2q.py	1970-01-01 00:00:00 +0000
@@ -1,2763 +0,0 @@
-# -*- test-case-name: vertex.test.test_q2q -*-
-# Copyright 2005-2008 Divmod, Inc.  See LICENSE file for details
-
-"""
-I{Quotient to Quotient} protocol implementation.
-"""
-
-# stdlib
-import itertools
-from hashlib import md5
-import struct
-import datetime
-import time
-from collections import namedtuple
-
-from pprint import pformat
-
-from zope.interface import implements
-
-# twisted
-from twisted.internet import reactor, defer, interfaces, protocol, error
-from twisted.internet.main import CONNECTION_DONE
-from twisted.internet.ssl import (
-    CertificateRequest, Certificate, PrivateCertificate, KeyPair,
-    DistinguishedName)
-from twisted.python import log
-from twisted.python.failure import Failure
-from twisted.application import service
-
-# twisted.cred
-from twisted.cred.checkers import ICredentialsChecker
-from twisted.cred.portal import IRealm, Portal
-from twisted.cred.credentials import IUsernamePassword, UsernamePassword
-from twisted.cred.error import UnauthorizedLogin
-
-from twisted.protocols.amp import Argument, Boolean, Integer, String, Unicode, ListOf, AmpList
-from twisted.protocols.amp import AmpBox, Command, StartTLS, ProtocolSwitchCommand, AMP
-from twisted.protocols.amp import _objectsToStrings
-
-# vertex
-from vertex import subproducer, ptcp
-from vertex import endpoint, ivertex
-from vertex.conncache import ConnectionCache
-
-MESSAGE_PROTOCOL = 'q2q-message'
-port = 8788
-
-class ConnectionError(Exception):
-    pass
-
-class AttemptsFailed(ConnectionError):
-    pass
-
-class NoAttemptsMade(ConnectionError):
-    pass
-
-class VerifyError(Exception):
-    pass
-
-class BadCertificateRequest(VerifyError):
-    pass
-
-class IgnoreConnectionFailed(protocol.ClientFactory):
-    def __init__(self, realFactory):
-        self.realFactory = realFactory
-
-    def clientConnectionLost(self, connector, reason):
-        self.realFactory.clientConnectionLost(connector, reason)
-
-    def clientConnectionFailed(self, connector, reason):
-        pass
-
-    def buildProtocol(self, addr):
-        return self.realFactory.buildProtocol(addr)
-
-class Q2QAddress(object):
-    def __init__(self, domain, resource=None):
-        self.resource = resource
-        self.domain = domain
-
-    def domainAddress(self):
-        """ Return an Address object which is the same as this one with ONLY the
-        'domain' attribute set, not 'resource'.
-
-        May return 'self' if 'resource' is already None.
-        """
-        if self.resource is None:
-            return self
-        else:
-            return Q2QAddress(self.domain)
-
-    def claimedAsIssuerOf(self, cert):
-        """
-        Check if the information in a provided certificate *CLAIMS* to be issued by
-        this address.
-
-        PLEASE NOTE THAT THIS METHOD IS IN NO WAY AUTHORITATIVE.  It does not
-        perform any cryptographic checks.
-
-        Currently this check is if L{Q2QAddress.__str__}C{(self)} is equivalent
-        to the commonName on the certificate's issuer.
-        """
-        return cert.getIssuer().commonName == str(self)
-
-    def claimedAsSubjectOf(self, cert):
-        """
-        Check if the information in a provided certificate *CLAIMS* to be
-        provided for use by this address.
-
-        PLEASE NOTE THAT THIS METHOD IS IN NO WAY AUTHORITATIVE.  It does not
-        perform any cryptographic checks.
-
-        Currently this check is if L{Q2QAddress.__str__}C{(self)} is equivalent
-        to the commonName on the certificate's subject.
-        """
-        return cert.getSubject().commonName == str(self)
-
-    def __cmp__(self, other):
-        if not isinstance(other, Q2QAddress):
-            return cmp(self.__class__, other.__class__)
-        return cmp((self.domain, self.resource), (other.domain, other.resource))
-
-    def __iter__(self):
-        return iter((self.resource, self.domain))
-
-    def __str__(self):
-        """
-        Return a string of the normalized form of this address.  e.g.::
-
-            [e-mail]    # for a user
-            divmod.com          # for a domain
-        """
-        if self.resource:
-            resource = self.resource + '@'
-        else:
-            resource = ''
-        return (resource + self.domain).encode('utf-8')
-
-    def __repr__(self):
-        return '<Q2Q at %s>' % self.__str__()
-
-    def __hash__(self):
-        return hash(str(self))
-
-    def fromString(cls, string):
-        args = string.split("@",1)
-        args.reverse()
-        return cls(*args)
-    fromString = classmethod(fromString)
-
-
-class VirtualTransportAddress:
-    def __init__(self, underlying):
-        self.underlying = underlying
-
-    def __repr__(self):
-        return 'VirtualTransportAddress(%r)' % (self.underlying,)
-
-class Q2QTransportAddress:
-    """
-    The return value of getPeer() and getHost() for Q2Q-enabled transports.
-    Passed to buildProtocol of factories passed to listenQ2Q.
-
-    @ivar underlying: The return value of the underlying transport's getPeer()
-    or getHost(); an address which indicates the path which the bytes carrying
-    Q2Q traffic are travelling over.  It is tempting to think of this as a
-    'physical' layer but that it not necessarily accurate; there are
-    potentially multiple layers of wrapping on any Q2Q transport, as an SSL
-    transport may be tunnelled over a UDP NAT-traversal layer.  Implements
-    C{IAddress} from Twisted, for all the good that will do you.
-
-    @ivar logical: a L{Q2QAddress}, The logical peer; the user ostensibly
-    listening to data on the other end of this transport.
-
-    @ivar protocol: a L{str}, the name of the protocol that is connected.
-    """
-
-    def __init__(self, underlying, logical, protocol):
-        self.underlying = underlying
-        self.logical = logical
-        self.protocol = protocol
-
-    def __repr__(self):
-        return 'Q2QTransportAddress(%r, %r, %r)' % (
-            self.underlying,
-            self.logical,
-            self.protocol)
-
-
-class AmpTime(Argument):
-    def toString(self, inObject):
-        return inObject.strftime("%Y-%m-%dT%H:%M:%S")
-
-
-    def fromString(self, inString):
-        return datetime.datetime.strptime(inString, "%Y-%m-%dT%H:%M:%S")
-
-
-
-class Q2QAddressArgument(Argument):
-    fromString = Q2QAddress.fromString
-    toString = Q2QAddress.__str__
-
-class HostPort(Argument):
-    def toString(self, inObj):
-        return "%s:%d" % tuple(inObj)
-
-    def fromString(self, inStr):
-        host, sPort = inStr.split(":")
-        return (host, int(sPort))
-
-
-
-class _BinaryLoadable(String):
-    def toString(self, arg):
-        assert isinstance(arg, self.loader), "%r not %r" % (arg, self.loader)
-        return String.toString(self, arg.dump())
-
-    def fromString(self, arg):
-        return self.loader.load(String.fromString(self, arg))
-
-class CertReq(_BinaryLoadable):
-    loader = CertificateRequest
-
-class Cert(_BinaryLoadable):
-    loader = Certificate
-
-from twisted.internet import protocol
-
-class Q2QClientProtocolFactoryWrapper:
-
-    def __init__(self, service, cpf, fromAddress, toAddress, protocolName,
-                 connectionEstablishedDeferred):
-        self.service = service
-        self.cpf = cpf
-        self.fromAddress = fromAddress
-        self.toAddress = toAddress
-        self.protocolName = protocolName
-        self.connectionEstablishedDeferred = connectionEstablishedDeferred
-        connectionEstablishedDeferred.addCallback(self.setMyClient)
-
-    myClient = None
-    def setMyClient(self, myClient):
-        # print '***CLIENT SET***', self, self.fromAddress, self.toAddress, self.cpf
-        self.myClient = myClient
-        return myClient
-
-    def buildProtocol(self, addr):
-        # xxx modify addr to include q2q information.
-        subProto = self.cpf.buildProtocol(self.toAddress)
-        myProto = SeparateConnectionTransport(self.service, subProto, self.fromAddress,
-                                              self.toAddress, self.protocolName,
-                                              self.connectionEstablishedDeferred)
-        return myProto
-
-    def clientConnectionFailed(self, connector, reason):
-        # DON'T forward this to our client protocol factory; only one attempt
-        # has failed; let that happen later, when _ALL_ attempts have failed.
-        assert self.myClient is None
-        self.connectionEstablishedDeferred.errback(reason)
-
-    def clientConnectionLost(self, connector, reason):
-        # as in clientConnectionFailed, don't bother to forward; this
-        # clientConnectionLost is actually a clientConnectionFailed for the
-        # underlying transport.
-        if self.myClient is not None:
-            # forward in this case because it's likely that we need to pass it
-            # along...
-            self.cpf.clientConnectionLost(connector, reason)
-
-    def doStart(self):
-        self.cpf.doStart()
-
-    def doStop(self):
-        self.cpf.doStop()
-
-class ImmediatelyLoseConnection(protocol.Protocol):
-    def connectionMade(self):
-        self.transport.loseConnection()
-
-class AbstractConnectionAttempt(protocol.ClientFactory):
-
-
-    def __init__(self, method, q2qproto, connectionID, fromAddress, toAddress,
-                 protocolName, clientProtocolFactory, issueGreeting=False):
-        self.method = method
-        self.q2qproto = q2qproto
-        assert isinstance(connectionID, str)
-        self.connectionID = connectionID
-        self.q2qproto = q2qproto
-        self.fromAddress = fromAddress
-        self.toAddress = toAddress
-        self.protocolName = protocolName
-        self.deferred = defer.Deferred()
-        self.clientProtocolFactory = Q2QClientProtocolFactoryWrapper(
-            q2qproto.service,
-            clientProtocolFactory, fromAddress, toAddress, protocolName,
-            self.deferred)
-        self.issueGreeting = issueGreeting
-
-
-    def startAttempt(self):
-        """
-        +-+
-        |?|
-        +-+
-        """
-        raise NotImplementedError()
-
-
-    q2qb = None
-
-    cancelled = False
-
-    def buildProtocol(self, addr):
-        if self.cancelled:
-            return ImmediatelyLoseConnection()
-        assert self.q2qb is None
-        self.q2qb = Q2QBootstrap(
-            self.connectionID, self.clientProtocolFactory)
-        return self.q2qb
-
-    def clientConnectionFailed(self, connector, reason):
-        """
-        """
-        # Don't bother forwarding.  In fact this should probably never be
-        # called because we're not bothering to forward them along from
-        # Q2QClientProtocolFactoryWrapper
-
-    def clientConnectionLost(self, connector, reason):
-        """
-        """
-        # we don't care - this will be handled by Q2QBootstrap.
-
-    def cancel(self):
-        """
-        - Stop attempting to connect.
-
-        - If a connection is somehow made after this has been cancelled, reject
-          it.
-
-        - Clean up any resources, such as listening UDP or TCP ports,
-          associated with this connection attempt [obviously, that are unshared
-          by other connection attempt]
-
-        """
-        self.cancelled = True
-
-
-class TCPConnectionAttempt(AbstractConnectionAttempt):
-    attempted = False
-    def startAttempt(self):
-        assert not self.attempted
-        self.attempted = True
-        reactor.connectTCP(self.method.host, self.method.port, self)
-        return self.deferred
-
-
-class TCPMethod:
-    def __init__(self, hostport):
-        self.host, port = hostport.split(':')
-        self.port = int(port)
-
-    attemptFactory = TCPConnectionAttempt
-    relayable = True
-    ptype = 'tcp'
-
-    def toString(self):
-        return '%s@%s:%d' % (self.ptype, self.host, self.port)
-
-    def __repr__(self):
-        return '<%s>'%self.toString()
-
-    def attempt(self, *a):
-        return [self.attemptFactory(self, *a)]
-
-connectionCounter = itertools.count().next
-connectionCounter()
-
-class VirtualConnectionAttempt(AbstractConnectionAttempt):
-    attempted = False
-    def startAttempt(self):
-        assert not self.attempted
-        self.attempted = True
-        cid = connectionCounter()
-        if self.q2qproto.isServer:
-            cid = -cid
-        innerTransport = VirtualTransport(self.q2qproto, cid, self, True)
-        def startit(result):
-            proto = innerTransport.startProtocol()
-            return self.deferred
-
-        d = self.q2qproto.callRemote(Virtual, id=cid)
-        d.addCallback(startit)
-        return d
-
-
-class VirtualMethod:
-    def __init__(self, virt=None):
-        pass
-
-    relayable = False
-
-    def toString(self):
-        return 'virtual'
-
-    def __repr__(self):
-        return '<%s>' % (self.toString(),)
-
-    def attempt(self, *a):
-        return [VirtualConnectionAttempt(self, *a)]
-
-
-class _PTCPConnectionAttempt1NoPress(AbstractConnectionAttempt):
-    attempted = False
-    def startAttempt(self):
-        assert not self.attempted
-        self.attempted = True
-        svc = self.q2qproto.service
-        dsp = svc.dispatcher
-        dsp.connectPTCP(
-            self.method.host, self.method.port, self,
-            svc.sharedUDPPortnum)
-        return self.deferred
-
-class _PTCPConnectionAttemptPress(AbstractConnectionAttempt):
-    attempted = False
-    def startAttempt(self):
-        assert not self.attempted
-        self.attempted = True
-
-        svc = self.q2qproto.service
-        dsp = svc.dispatcher
-        newPort = self.newPort = dsp.bindNewPort()
-        dsp.connectPTCP(
-            self.method.host, self.method.port, self,
-            newPort)
-
-        return self.deferred
-
-    def cancel(self):
-        if not self.cancelled:
-            self.q2qproto.service.dispatcher.unbindPort(self.newPort)
-        else:
-            print 'totally wacky, [press] cancelled twice!'
-        AbstractConnectionAttempt.cancel(self)
-
-class PTCPMethod(TCPMethod):
-    """Pseudo-TCP method.
-    """
-    ptype = 'ptcp'
-
-    def attempt(self, *a):
-        return [_PTCPConnectionAttempt1NoPress(self, *a),
-                _PTCPConnectionAttemptPress(self, *a)]
-
-class RPTCPConnectionAttempt(AbstractConnectionAttempt):
-    attempted = False
-    def startAttempt(self):
-        assert not self.attempted
-        self.attempted = True
-
-        realLocalUDP = self.newPort = self.q2qproto.service.dispatcher.seedNAT((self.method.host, self.method.port))
-        # self.host and self.port are remote host and port
-        # realLocalUDP is a local port
-
-        # The arguments here are given from the perspective of the recipient of
-        # the command. we are asking the recipient of the connection to map a
-        # NAT entry of a pre-existing listening UDP socket on their end of the
-        # connection by sending us some traffic.  therefore the src is their
-        # endpoint, the dst is our endpoint, the user we are asking them to
-        # send TO is us, the user we are asking them to accept this FROM is us.
-
-        # we include protocol as an arg because this is helpful for relaying.
-
-        def enbinden(boundereded):
-            if not self.cancelled:
-                self.q2qproto.service.dispatcher.connectPTCP(
-                    self.method.host, self.method.port, self, realLocalUDP
-                    )
-            return self.deferred
-
-        def swallowKnown(error):
-            error.trap(ConnectionError)
-            self.deferred.errback(CONNECTION_DONE)
-            return self.deferred
-
-        d = self.q2qproto.callRemote(
-            BindUDP,
-            q2qsrc=self.toAddress,
-            q2qdst=self.fromAddress,
-            protocol=self.protocolName,
-            udpsrc=(self.method.host, self.method.port),
-            udpdst=(self.q2qproto._determinePublicIP(), realLocalUDP))
-        d.addCallbacks(enbinden, swallowKnown)
-        return d
-
-    def cancel(self):
-        if not self.cancelled:
-            self.q2qproto.service.dispatcher.unbindPort(self.newPort)
-        else:
-            print 'totally wacky, [rptcp] cancelled twice!'
-        AbstractConnectionAttempt.cancel(self)
-
-
-
-
-class RPTCPMethod(TCPMethod):
-    """ Certain NATs respond very poorly to seed traffic: e.g. if they receive
-    unsolicited traffic to a particular port, they will make that outbound port
-    unavailable for outbound traffic originated internally.  The
-    Reverse-Pseudo-TCP method is a way to have the *sender* send the first UDP
-    packet, so they will bind it.
-
-    This is a worst-case scenario: if both ends of the connection have NATs
-    which behave this way, there is no way to establish a connection.
-    """
-
-    ptype = 'rptcp'
-    attemptFactory = RPTCPConnectionAttempt
-
-
-class UnknownMethod:
-
-    relayable = True
-
-    def __init__(self, S):
-        self.string = S
-
-    def attemptConnect(self, q2qproto, connectionID, From, to,
-                       protocolName, protocolFactory):
-        return defer.fail(Failure(ConnectionError(
-                    "unknown connection method: %s" % (self.string,))))
-
-
-_methodFactories = {'virtual': VirtualMethod,
-                    'tcp': TCPMethod,
-                    'ptcp': PTCPMethod,
-                    'rptcp': RPTCPMethod}
-
-class Method(Argument):
-    def toString(self, inObj):
-        return inObj.toString()
-
-
-    def fromString(self, inString):
-        f = inString.split("@", 1)
-        factoryName = f[0]
-        if len(f) > 1:
-            factoryData = f[1]
-        else:
-            factoryData = ''
-        methodFactory = _methodFactories.get(factoryName, None)
-        if methodFactory is None:
-            factory = UnknownMethod(inString)
-        else:
-            factory = methodFactory(factoryData)
-        return factory
-
-
-class Secure(StartTLS):
-
-    commandName = "secure"
-    arguments = StartTLS.arguments + [
-        ('From', Q2QAddressArgument(optional=True)),
-        ('to', Q2QAddressArgument()),
-        ('authorize', Boolean())
-        ]
-
-
-
-class Listen(Command):
-    """
-    A simple command for registering interest with an active Q2Q connection
-    to hear from a server when others come calling.  An occurrence of this
-    command might have this appearance on the wire::
-
-        C: -Command: Listen
-        C: -Ask: 1
-        C: From: [e-mail]
-        C: Protocols: q2q-example, q2q-example2
-        C: Description: some simple protocols
-        C:
-        S: -Answer: 1
-        S:
-
-    This puts some state on the server side that will affect any Connect
-    commands with q2q-example or q2q-example2 in the Protocol: header.
-    """
-
-    commandName = 'listen'
-    arguments = [
-        ('From', Q2QAddressArgument()),
-        ('protocols', ListOf(String())),
-        ('description', Unicode())]
-
-    result = []
-
-class ConnectionStartBox(AmpBox):
-    def __init__(self, __transport):
-        super(ConnectionStartBox, self).__init__()
-        self.virtualTransport = __transport
-
-    # XXX Overriding a private interface
-    def _sendTo(self, proto):
-        super(ConnectionStartBox, self)._sendTo(proto)
-        self.virtualTransport.startProtocol()
-
-class Virtual(Command):
-    commandName = 'virtual'
-    result = []
-
-    arguments = [('id', Integer())]
-
-    def makeResponse(cls, objects, proto):
-        tpt = objects.pop('__transport__')
-        # XXX Using a private API
-        return _objectsToStrings(
-            objects, cls.response,
-            ConnectionStartBox(tpt),
-            proto)
-
-    makeResponse = classmethod(makeResponse)
-
-class Identify(Command):
-    """
-    Respond to an IDENTIFY command with a self-signed certificate for the
-    domain requested, assuming we are an authority for said domain.  An
-    occurrence of this command might have this appearance on the wire::
-
-        C: -Command: Identify
-        C: -Ask: 1
-        C: Domain: divmod.com
-        C:
-        S: -Answer: 1
-        S: Certificate: <<<base64-encoded self-signed certificate of divmod.com>>>
-        S:
-
-    """
-
-    commandName = 'identify'
-
-    arguments = [('subject', Q2QAddressArgument())]
-
-    response = [('certificate', Cert())]
-
-class BindUDP(Command):
-    """
-    See UDPXMethod
-    """
-
-    commandName = 'bind-udp'
-
-    arguments = [
-        ('protocol', String()),
-        ('q2qsrc', Q2QAddressArgument()),
-        ('q2qdst', Q2QAddressArgument()),
-        ('udpsrc', HostPort()),
-        ('udpdst', HostPort()),
-        ]
-
-    errors = {ConnectionError: 'ConnectionError'}
-
-    response = []
-
-class SourceIP(Command):
-    """
-    Ask a server on the public internet what my public IP probably is.  An
-    occurrence of this command might have this appearance on the wire::
-
-        C: -Command: Source-IP
-        C: -Ask: 1
-        C:
-        S: -Answer: 1
-        S: IP: 4.3.2.1
-        S:
-
-    """
-
-    commandName = 'source-ip'
-
-    arguments = []
-
-    response = [('ip', String())]
-
-class Inbound(Command):
-    """
-    Request information about where to connect to a particular resource.
-
-    Generally speaking this is an "I want to connect to you" request.
-
-    The format of this request is transport neutral except for the optional
-    'Udp_Source' header, which specifies an IP/Port pair for all receiving peers to
-    send an almost-empty (suggested value of '\\r\\n') UDP packet to to help
-    with NAT traversal issues.
-
-    See L{Q2QService.connectQ2Q} for details.
-
-    An occurrence of this command might have this appearance on the wire::
-
-        C: -Command: Inbound
-        C: -Ask: 1
-        C: From: [e-mail]
-        C: Id: [e-mail]
-        C: To: [e-mail]
-        C: Protocol: q2q-example
-        C: Udp_Source: 1.2.3.4:4321
-        C:
-        S: -Answer: 1
-        S: Listeners:
-        S:  Description: at lab
-        S:  Methods: tcp@18.38.12.4:3827, virtual
-        S:
-        S:  Description: my home machine
-        S:  Methods: tcp@187.48.38.3:49812, udp@187.48.38.3:49814, virtual
-
-    Now the connection-id has been registered and either client or server can
-    issue WRITE or CLOSE commands.
-
-    Failure modes::
-
-      - "NotFound": the toResource or toDomain is invalid, or the resource does
-        not speak that protocol.
-
-      - "VerifyError": Authenticity or security for the requested connection
-        could not be authorized.  This is a fatal error: the connection will be
-        dropped.
-
-    The "Udp_Source" header indicates the address from which this Inbound chain
-    originated.  It is to be used to establish connections where possible
-    between NATs which require traffic between two host/port pairs to be
-    bidirectional before a "hole" is established, such as port restricted cone
-    and symmetric NATs.  (Note, this only has about a 30% probability of
-    working on a symmetric NAT, but it's worth trying sometimes anyway).  Any
-    UDP-based connection methods (currently only Gin, but in principle others
-    such as RTP, RTCP, SIP and Quake traffic) that wish to use this connection
-    must first send some garbage traffic to the host/port specified by the
-    "Udp_Source" header.
-
-    The response is a list of "listeners" - a small (unicode) textual
-    description of a host, plus a list of methods describing how to connect to
-    it.
-    """
-
-    commandName = 'inbound'
-    arguments = [('From', Q2QAddressArgument()),
-                 ('to', Q2QAddressArgument()),
-                 ('protocol', String()),
-                 ('udp_source', HostPort(optional=True))]
-
-    response = [('listeners', AmpList(
-                [('id', String()),
-                 ('certificate', Cert(optional=True)),
-                 ('methods', ListOf(Method())),
-                 ('expires', AmpTime()),
-                 ('description', Unicode())]))]
-
-    errors = {KeyError: "NotFound"}
-    fatalErrors = {VerifyError: "VerifyError"}
-
-class Outbound(Command):
-    """Similar to Inbound, but _requires that the recipient already has the
-    id parameter as an outgoing connection attempt_.
-    """
-    commandName = 'outbound'
-
-    arguments = [('From', Q2QAddressArgument()),
-                 ('to', Q2QAddressArgument()),
-                 ('protocol', String()),
-                 ('id', String()),
-                 ('methods', ListOf(Method()))]
-
-    response = []
-
-    errors = {AttemptsFailed: 'AttemptsFailed'}
-
-class Sign(Command):
-    commandName = 'sign'
-    arguments = [('certificate_request', CertReq()),
-                 ('password', String())]
-
-    response = [('certificate', Cert())]
-
-    errors = {KeyError: "NoSuchUser",
-              BadCertificateRequest: "BadCertificateRequest"}
-
-class Choke(Command):
-    """Ask our peer to be quiet for a while.
-    """
-    commandName = 'Choke'
-    arguments = [('id', Integer())]
-    requiresAnswer = False
-
-
-class Unchoke(Command):
-    """Reverse the effects of a choke.
-    """
-    commandName = 'Unchoke'
-    arguments = [('id', Integer())]
-    requiresAnswer = False
-
-
-def safely(f, *a, **k):
-    """try/except around something, w/ twisted error handling.
-    """
-    try:
-        f(*a,**k)
-    except:
-        log.err()
-
-class Q2Q(AMP, subproducer.SuperProducer):
-    """ Quotient to Quotient protocol.
-
-    At a low level, this uses a protocol called 'Juice' (JUice Is Concurrent
-    Events), which is a simple rfc2822-inspired (although not -compliant)
-    protocol for request/response pair hookup.
-
-    At a higher level, it provides a mechanism for SSL certificate exchange,
-    looking up physical locations of users' data, and switching into other
-    protocols after an initial handshake.
-
-    @ivar publicIP: The IP that the other end of the connection claims to know
-    us by.  This will be used when responding to L{Inbound} commands if the Q2Q
-    service I am attached to does not specify a public IP to use.
-
-    @ivar authorized: A boolean indicating whether SSL verification has taken
-    place to ensure that this connection's peer has claimed an accurate identity.
-    """
-
-    protocolName = 'q2q'
-    service = None
-    publicIP = None
-    authorized = False
-
-    def __init__(self, *a, **kw):
-        """ Q2Q instances should only be created by Q2QService.  See
-        L{Q2QService.connectQ2Q} and L{Q2QService.listenQ2Q}.
-        """
-        subproducer.SuperProducer.__init__(self)
-        AMP.__init__(self, *a, **kw)
-
-    def connectionMade(self):
-        self.producingTransports = {}
-        self.connections = {}
-        self.listeningClient = []
-        self.connectionObservers = []
-        if self.service.publicIP is None:
-            log.msg("Service has no public IP: determining")
-            self.service.publicIP = self.transport.getHost().host
-            self.service._publicIPIsReallyPrivate = True
-            def rememberPublicIP(pubip):
-                ip = pubip['ip']
-                log.msg('remembering public ip as %r' % ip)
-                self.publicIP = ip
-                self.service.publicIP = ip
-                self.service._publicIPIsReallyPrivate = False
-            self.callRemote(SourceIP).addCallback(rememberPublicIP)
-        else:
-            log.msg("Using existing public IP: %r" % (self.service.publicIP,))
-
-    def connectionLost(self, reason):
-        ""
-        AMP.connectionLost(self, reason)
-        self._uncacheMe()
-        self.producingTransports = {}
-        for key, value in self.listeningClient:
-            log.msg("removing remote listener for %r" % (key,))
-            self.service.listeningClients[key].remove(value)
-        self.listeningClient = []
-        for xport in self.connections.values():
-            safely(xport.connectionLost, reason)
-        for observer in self.connectionObservers:
-            safely(observer)
-
-    def notifyOnConnectionLost(self, observer):
-        ""
-        self.connectionObservers.append(observer)
-
-    def _bindUDP(self, q2qsrc, q2qdst, udpsrc, udpdst, protocol):
-
-        # we are representing the src, because they are the ones being told to
-        # originate a UDP packet.
-
-        self.verifyCertificateAllowed(q2qsrc, q2qdst)
-
-        # if I've got a local factory for this 3-tuple, do the bind if I own
-        # this IP...
-        srchost, srcport = udpsrc
-
-        lcget = self.service.listeningClients.get((q2qsrc, protocol), ())
-
-        bindery = []
-
-        for (listener, listenCert, desc
-                 ) in lcget:
-            # print 'looking at listener', listener
-            # print listener.transport.getPeer().host, srchost
-            if listener.transport.getPeer().host == srchost:
-                # print 'bound in clients loop'
-
-                d = listener.callRemote(
-                    BindUDP,
-                    q2qsrc=q2qsrc,
-                    q2qdst=q2qdst,
-                    udpsrc=udpsrc,
-                    udpdst=udpdst,
-                    protocol=protocol)
-                def swallowKnown(err):
-                    err.trap(error.ConnectionDone, error.ConnectionLost)
-                d.addErrback(swallowKnown)
-                bindery.append(d)
-        if bindery:
-            # print 'bindery return', len(bindery)
-            def _justADict(ign):
-                return dict()
-            return defer.DeferredList(bindery).addCallback(_justADict)
-
-        # print 'what?', lcget
-        if (self.service.getLocalFactories(q2qdst, q2qsrc, protocol)
-            and srchost == self._determinePublicIP()):
-            self.service.dispatcher.seedNAT(udpdst, srcport, conditional=True)
-            # print 'bound locally'
-            return dict()
-        # print 'conn-error'
-        raise ConnectionError("unable to find appropriate UDP binder")
-
-    BindUDP.responder(_bindUDP)
-
-    def _identify(self, subject):
-        """
-        Implementation of L{Identify}.
-        """
-        ourCA = self.service.certificateStorage.getPrivateCertificate(str(subject))
-        return dict(certificate=ourCA)
-    Identify.responder(_identify)
-
-
-    def verifyCertificateAllowed(self,
-                                 ourAddress,
-                                 theirAddress):
-        """
-        Check that the certificate currently in use by this transport is valid to
-        claim that the connection offers authorization for this host speaking
-        for C{ourAddress}, to a host speaking for C{theirAddress}.  The remote
-        host (the one claiming to use theirAddress) may have a certificate
-        which is issued for the domain for theirAddress or the full address
-        given in theirAddress.
-
-        This method runs B{after} cryptographic verification of the validity of
-        certificates, although it does not perform any cryptographic checks
-        itself.  It depends on SSL connection handshaking - *and* the
-        particular certificate lookup logic which prevents spoofed Issuer
-        fields, to work properly.  However, all it checks is the X509 names
-        present in the certificates matching with the application-level
-        security claims being made by our peer.
-
-        An example of successful verification, because both parties have
-        properly signed certificates for their usage from the domain they
-        have been issued::
-
-            our current certficate:
-                issuer: divmod.com
-                subject: [e-mail]
-            their current certificate:
-                issuer: twistedmatrix.com
-                subject: [e-mail]
-            Arguments to verifyCertificateAllowed:
-                ourAddress: [e-mail]
-                theirAddress: [e-mail]
-            Result of verifyCertificateAllowed: None
-
-        An example of rejected verification, because domain certificates are
-        always B{self}-signed in Q2Q; verisign is not a trusted certificate
-        authority for the entire internet as with some other TLS
-        implementations::
-
-            our current certificate:
-                issuer: divmod.com
-                subject: divmod.com
-            their current certificate:
-                issuer: verisign.com
-                subject: twistedmatrix.com
-            Arguments to verifyCertificateAllowed:
-                ourAddress: divmod.com
-                theirAddress: twistedmatrix.com
-            Result of verifyCertificateAllowed: exception VerifyError raised
-
-        Another example of successful verification, because we assume our
-        current certificate is under the control of this side of the
-        connection, so *any* claimed subject is considered acceptable::
-
-            our current certificate:
-                issuer: divmod.com
-                subject: divmod.com
-            their current certificate:
-                issuer: divmod.com
-                subject: [e-mail]
-            Arguments to verifyCertificateAllowed:
-                ourAddress: divmod.com
-                theirAddress: [e-mail]
-            Result of verifyCertificateAllowed: None
-
-        Another example of successful verification, because the user is
-        claiming to be anonymous; there is also a somewhat looser
-        cryptographic check applied to signatures for anonymous
-        connections::
-
-            our current certificate:
-                issuer: divmod.com
-                subject: divmod.com
-            their current certificate:
-                issuer: @
-                subject: @
-            arguments to verifyCertificateAllowed:
-                ourAddress: divmod.com
-                theirAddress: @
-            Result of verifyCertificateAllowed: None
-
-        Accept anonymous connections with caution.
-
-        @param ourAddress: a L{Q2QAddress} representing the address that we are
-        supposed to have authority for, requested by our peer.
-
-        @param theirAddress: a L{Q2QAddress} representing the address that our
-        network peer claims to be communicating on behalf of.  For example, if
-        our peer is foobar.com they may claim to be operating on behalf of any
-        user @foobar.com.
-
-        @raise: L{VerifyError} if the certificates do not match the
-        claimed addresses.
-        """
-
-        # XXX TODO: Somehow, it's got to be possible for a single cluster to
-        # internally claim to be agents of any other host when issuing a
-        # CONNECT; in other words, we always implicitly trust ourselves.  Also,
-        # we might want to issue anonymous CONNECTs over unencrypted
-        # connections.
-
-        # IOW: *we* can sign a certificate to be whoever, but the *peer* can
-        # only sign the certificate to be the peer.
-
-        # The easiest way to make this work is to issue ourselves a wildcard
-        # certificate.
-
-        if not self.authorized:
-            if theirAddress.domain == '':
-                # XXX TODO: document this rule, anonymous connections are
-                # allowed to not be authorized because they are not making any
-                # claims about who they are
-
-                # XXX also TODO: make it so that anonymous connections are
-                # disabled by default for most protocols
-                return True
-            raise VerifyError("No official negotiation has taken place.")
-
-        peerCert = Certificate.peerFromTransport(self.transport)
-        ourCert = self.hostCertificate
-
-        ourClaimedDomain = ourAddress.domainAddress()
-        theirClaimedDomain = theirAddress.domainAddress()
-
-        # Sanity check #1: did we pick the right certificate on our end?
-        if not ourClaimedDomain.claimedAsIssuerOf(ourCert):
-            raise VerifyError(
-                "Something has gone horribly wrong: local domain mismatch "
-                "claim: %s actual: %s" % (ourClaimedDomain,
-                                          ourCert.getIssuer()))
-        if theirClaimedDomain.claimedAsIssuerOf(peerCert):
-            # Their domain issued their certificate.
-            if theirAddress.claimedAsSubjectOf(peerCert) or theirClaimedDomain.claimedAsSubjectOf(peerCert):
-                return
-        elif ourClaimedDomain.claimedAsIssuerOf(peerCert):
-            # *our* domain can spoof *anything*
-            return
-        elif ourAddress.claimedAsIssuerOf(peerCert):
-            # Neither our domain nor their domain signed this.  Did *we*?
-            # (Useful in peer-to-peer persistent transactions where we don't
-            # want the server involved: [e-mail] can sign
-            # [e-mail]'s certificate).
-            return
-
-        raise VerifyError(
-            "Us: %s Them: %s "
-            "TheyClaimWeAre: %s TheyClaimTheyAre: %s" %
-            (ourCert, peerCert,
-             ourAddress, theirAddress))
-
-    def _listen(self, protocols, From, description):
-        """
-        Implementation of L{Listen}.
-        """
-        # The peer is coming from a client-side representation of the user
-        # described by 'From', and talking *to* a server-side representation of
-        # the user described by 'From'.
-        self.verifyCertificateAllowed(From, From)
-        theirCert = Certificate.peerFromTransport(self.transport)
-        for protocolName in protocols:
-            if protocolName.startswith('.'):
-                raise VerifyError(
-                    "Internal protocols are for server-server use _only_: %r" %
-                    protocolName)
-
-            key = (From, protocolName)
-            value = (self, theirCert, description)
-            log.msg("%r listening for %r" % key)
-            self.listeningClient.append((key, value))
-            self.service.listeningClients.setdefault(key, []).append(value)
-        return {}
-    Listen.responder(_listen)
-
-
-    def _inbound(self, From, to, protocol, udp_source=None):
-        """
-        Implementation of L{Inbound}.
-        """
-        # Verify stuff!
-
-        self.verifyCertificateAllowed(to, From)
-        return self.service.verifyHook(From, to, protocol
-                                       ).addCallback(self._inboundimpl,
-                                                     From,
-                                                     to,
-                                                     protocol,
-                                                     udp_source).addErrback(
-            lambda f: f.trap(KeyError) and dict(listeners=[]))
-    Inbound.responder(_inbound)
-
-    def _inboundimpl(self, ign, From, to, protocol, udp_source):
-
-        # 2-tuples of factory, description
-        srvfacts = self.service.getLocalFactories(From, to, protocol)
-
-        result = []             # list of listener dicts
-
-        if srvfacts:
-            log.msg("local factories found for inbound request: %r" % (srvfacts,))
-            localMethods = []
-            publicIP = self._determinePublicIP()
-            privateIP = self._determinePrivateIP()
-            if self.service.inboundTCPPort is not None:
-                tcpPort = self.service.inboundTCPPort.getHost().port
-                localMethods.append(TCPMethod(
-                        '%s:%d' %
-                        (publicIP, tcpPort)))
-                if publicIP != privateIP:
-                    localMethods.append(TCPMethod(
-                            '%s:%d' %
-                            (privateIP, tcpPort)))
-
-            if not self.service.udpEnabled:
-                log.msg("udp not enabled -- but I so want to send udp traffic!")
-            elif udp_source is None:
-                log.msg("udp_source was none on inbound")
-            else:
-                if self.service.dispatcher is None:
-                    log.msg("udp_source %s:%d, but dispatcher not running" %
-                            udp_source)
-                else:
-                    remoteUDPHost, remoteUDPPort = udp_source
-                    log.msg(
-                        "remote PTCP: %s:%d, "
-                        "local public IP: %s, local private IP: %s"
-                        % (remoteUDPHost, remoteUDPPort, publicIP, privateIP) )
-
-                    # Seed my NAT from my shared UDP port
-                    udpPort = self.service.dispatcher.seedNAT(udp_source, self.service.sharedUDPPortnum)
-
-                    if remoteUDPHost == publicIP and publicIP != privateIP:
-                        log.msg(
-                            "Remote IP matches local, public IP %r;"
-                            " preferring internal IP %r" % (publicIP, privateIP))
-                        localMethods.append(
-                            PTCPMethod("%s:%d" % (privateIP, udpPort)))
-                    localMethods.append(
-                        PTCPMethod("%s:%d" % (publicIP, udpPort)))
-
-                    # XXX CLEANUP!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                    privateUDPPort = self.service.dispatcher.seedNAT(udp_source)
-                    localMethods.append(
-                        PTCPMethod('%s:%d' % (publicIP, privateUDPPort)))
-
-                    udpxPort = self.service.dispatcher.seedNAT(udp_source)
-                    localMethods.append(
-                        RPTCPMethod("%s:%d" % (publicIP, udpxPort)))
-
-            if self.service.virtualEnabled:
-                localMethods.append(VirtualMethod())
-            log.msg('responding to inbound with local methods: %r' % (localMethods,))
-
-            for serverFactory, description in srvfacts:
-                expiryTime, listenID = self.service.mapListener(
-                    to, From, protocol, serverFactory)
-                result.append(dict(id=listenID,
-                                   expires=expiryTime,
-                                   methods=localMethods,
-                                   description=description))
-
-            # We've looked for our local factory.  Let's see if we have any
-            # listening protocols elsewhere.
-
-
-        key = (to, protocol)
-        if key in self.service.listeningClients:
-            args = dict(From=From,
-                        to=to,
-                        protocol=protocol,
-                        udp_source=udp_source)
-            DL = []
-            lclients = self.service.listeningClients[key]
-            log.msg("listeners found for %s:%r" % (to, protocol))
-            for listener, listenCert, desc in lclients:
-                log.msg("relaying inbound to %r via %r" % (to, listener))
-                DL.append(listener.callRemote(Inbound, **args).addCallback(
-                    self._massageClientInboundResponse, listener, result))
-
-            def allListenerResponses(x):
-                log.msg("all inbound responses received: %s" % (pformat(result),))
-                return dict(listeners=result)
-            return defer.DeferredList(DL).addCallback(allListenerResponses)
-        else:
-            log.msg("no listenening clients for %s:%r. local methods: %r" % (to,protocol, result))
-            return dict(listeners=result)
-
-
-    def _massageClientInboundResponse(self, inboundResponse, listener, result):
-        irl = inboundResponse['listeners']
-        log.msg("received relayed inbound response: %r via %r" %
-                (inboundResponse, listener))
-
-        for listenerInfo in irl:
-            # inboundResponse['description'] = ??? trust client version for
-            # now... maybe the server doesn't even need to know about
-            # descriptions...?
-            listenerInfo['methods'] = [
-                meth for meth in listenerInfo['methods'] if meth.relayable]
-            # make sure that the certificate that we're relaying matches the
-            # certificate that they gave us!
-            if listenerInfo['methods']:
-                allowedCertificate = Certificate.peerFromTransport(
-                    listener.transport)
-                listenerInfo['certificate'] = allowedCertificate
-                result.append(listenerInfo)
-
-    def _determinePublicIP(self):
-        reservePublicIP = None
-        if self.service.publicIP is not None:
-            if self.service._publicIPIsReallyPrivate:
-                reservePublicIP = self.service.publicIP
-            else:
-                return self.service.publicIP
-        if self.publicIP is not None:
-            return self.publicIP
-        if reservePublicIP is not None:
-            return reservePublicIP
-        return self._determinePrivateIP()
-
-    def _determinePrivateIP(self):
-        return self.transport.getHost().host
-
-    def _sourceIP(self):
-        result = {'ip': self.transport.getPeer().host}
-        return result
-    SourceIP.responder(_sourceIP)
-
-    def _resume(self, connection, data, writeDeferred):
-        try:
-            connection.dataReceived(data)
-        except:
-            writeDeferred.errback()
-        else:
-            writeDeferred.callback({})
-
-
-    def _choke(self, id):
-        connection = self.connections[id]
-        connection.choke()
-        return {}
-    Choke.responder(_choke)
-
-
-    def _unchoke(self, id):
-        connection = self.connections[id]
-        connection.unchoke()
-        return {}
-    Unchoke.responder(_unchoke)
-
-
-    def amp_WRITE(self, box):
-        """
-        Respond to a WRITE command, sending some data over a virtual channel
-        created by VIRTUAL.  The answer is simply an acknowledgement, as it is
-        simply meant to note that the write went through without errors.
-
-        An occurrence of I{Write} on the wire, together with the response
-        generated by this method, might have this apperance::
-
-            C: -Command: Write
-            C: -Ask: 1
-            C: -Length: 13
-            C: Id: [e-mail]->[e-mail]:q2q-example:0
-            C:
-            C: HELLO WORLD
-            C:
-            S: -Answer: 1
-            S:
-
-        """
-        id = int(box['id'])
-        if id not in self.connections:
-            raise error.ConnectionDone()
-        connection = self.connections[id]
-        data = box['body']
-        connection.dataReceived(data)
-        return AmpBox()
-
-    def amp_CLOSE(self, box):
-        """
-        Respond to a CLOSE command, dumping some data onto the stream.  As with
-        WRITE, this returns an empty acknowledgement.
-
-        An occurrence of I{Close} on the wire, together with the response
-        generated by this method, might have this apperance::
-
-            C: -Command: Close
-            C: -Ask: 1
-            C: Id: [e-mail]->[e-mail]:q2q-example:0
-            C:
-            S: -Answer: 1
-            S:
-
-        """
-        # The connection is removed from the mapping by connectionLost.
-        connection = self.connections[int(box['id'])]
-        connection.connectionLost(Failure(CONNECTION_DONE))
-        return AmpBox()
-
-
-    def _sign(self, certificate_request, password):
-        """
-        Respond to a request to sign a CSR for a user or agent located within
-        our domain.
-        """
-        if self.service.portal is None:
-            raise BadCertificateRequest("This agent cannot sign certificates.")
-
-        subj = certificate_request.getSubject()
-
-        sk = subj.keys()
-        if 'commonName' not in sk:
-            raise BadCertificateRequest(
-                "Certificate requested with bad subject: %s" % (sk,))
-
-        uandd = subj.commonName.split("@")
-        if len(uandd) != 2:
-            raise BadCertificateRequest("Won't sign certificates for other domains")
-        domain = uandd[1]
-
-        CS = self.service.certificateStorage
-        ourCert = CS.getPrivateCertificate(domain)
-
-        D = self.service.portal.login(
-            UsernamePassword(subj.commonName,
-                             password),
-            self,
-            ivertex.IQ2QUser)
-
-        def _(ial):
-            (iface, aspect, logout) = ial
-            ser = CS.genSerial(domain)
-            return dict(certificate=aspect.signCertificateRequest(
-                    certificate_request, ourCert, ser))
-
-        return D.addCallback(_)
-    Sign.responder(_sign)
-
-
-    def _secure(self, to, From, authorize):
-        """
-        Response to a SECURE command, starting TLS when necessary, and using a
-        certificate identified by the I{To} header.
-
-        An occurrence of I{Secure} on the wire, together with the response
-        generated by this method, might have the following appearance::
-
-            C: -Command: Secure
-            C: -Ask: 1
-            C: To: divmod.com
-            C: From: twistedmatrix.com
-            C: Authorize: True
-            C:
-            Client Starts TLS here with twistedmatrix.com certificate
-            S: -Answer: 1
-            S:
-            Server Starts TLS here with divmod.com certificate
-
-        """
-        if self.hostCertificate is not None:
-            raise RuntimeError("Re-encrypting already encrypted connection")
-        CS = self.service.certificateStorage
-        ourCert = CS.getPrivateCertificate(str(to.domainAddress()))
-        if authorize:
-            D = CS.getSelfSignedCertificate(str(From.domainAddress()))
-        else:
-            self.authorized = False
-            return {'tls_localCertificate': ourCert}
-
-        def hadCert(peerSigned):
-            self.authorized = True
-            self._cacheMeNow(From, to, authorize)
-            return {'tls_localCertificate': ourCert,
-                    'tls_verifyAuthorities': [peerSigned]}
-
-        def didNotHaveCert(err):
-            err.trap(KeyError)
-            return self._retrieveRemoteCertificate(From, port)
-
-        D.addErrback(didNotHaveCert)
-        D.addCallback(hadCert)
-
-        return D
-    Secure.responder(_secure)
-
-    _cachedUnrequested = False
-
-    def _cacheMeNow(self, From, to, authorize):
-        tcpeer = self.transport.getPeer()
-        # XXX 'port' is insane here, but we lack a better number to hash
-        # against.  perhaps the SECURE request should give a reciprocal
-        # connection identifier...?
-        self.service.secureConnectionCache.cacheUnrequested(
-            endpoint.TCPEndpoint(tcpeer.host, port),
-            (From, to.domain, authorize), self)
-        assert not self._cachedUnrequested
-        self._cachedUnrequested = (From, to, authorize, tcpeer)
-
-    def _uncacheMe(self):
-        if self._cachedUnrequested:
-            # If this is a client connection, this will never be called, since
-            # _cacheMeNow is called from the _server_ half of this business.
-            # The uncaching API here is a bit of a ragged edge of conncache.py;
-            # the interface should probably be cleaned up, but I don't think
-            # there are any functional problems with it.
-            From, to, authorize, tcpeer = self._cachedUnrequested
-            self.service.secureConnectionCache.connectionLostForKey(
-                (endpoint.TCPEndpoint(tcpeer.host, port),
-                 (From, to.domain, authorize)))
-
-    def _retrieveRemoteCertificate(self, From, port=port):
-        """
-        The entire conversation, starting with TCP handshake and ending at
-        disconnect, to retrieve a foreign domain's certificate for the first
-        time.
-        """
-        CS = self.service.certificateStorage
-        host = str(From.domainAddress())
-        p = AMP()
-        p.wrapper = self.wrapper
-        f = protocol.ClientCreator(reactor, lambda: p)
-        connD = f.connectTCP(host, port)
-
-        def connected(proto):
-            dhost = From.domainAddress()
-            iddom = proto.callRemote(Identify, subject=dhost)
-            def gotCert(identifyBox):
-                theirCert = identifyBox['certificate']
-                theirIssuer = theirCert.getIssuer().commonName
-                theirName = theirCert.getSubject().commonName
-                if (theirName != str(dhost)):
-                    raise VerifyError(
-                        "%r claimed it was %r in IDENTIFY response"
-                        % (theirName, dhost))
-                if (theirIssuer != str(dhost)):
-                    raise VerifyError(
-                        "self-signed %r claimed it was issued by "
-                        "%r in IDENTIFY response" % (dhost, theirIssuer))
-                def storedCert(ignored):
-                    return theirCert
-                return CS.storeSelfSignedCertificate(
-                    str(dhost), theirCert).addCallback(storedCert)
-            def nothingify(x):
-                proto.transport.loseConnection()
-                return x
-            return iddom.addCallback(gotCert).addBoth(nothingify)
-        connD.addCallback(connected)
-        return connD
-
-
-    def secure(self, fromAddress, toAddress,
-               fromCertificate, foreignCertificateAuthority=None,
-               authorize=True):
-        """Return a Deferred which fires True when this connection has been secured as
-        a channel between fromAddress (locally) and toAddress (remotely).
-        Raises an error if this is not possible.
-        """
-        if self.hostCertificate is not None:
-            raise RuntimeError("Re-securing already secured connection.")
-
-        def _cbSecure(response):
-            if foreignCertificateAuthority is not None:
-                self.authorized = True
-            return True
-        extra = {'tls_localCertificate': fromCertificate}
-        if foreignCertificateAuthority is not None:
-            extra['tls_verifyAuthorities'] = [foreignCertificateAuthority]
-
-        return self.callRemote(
-            Secure,
-            From=fromAddress,
-            to=toAddress,
-            authorize=authorize, **extra).addCallback(_cbSecure)
-
-    def _virtual(self, id):
-        if self.isServer:
-            assert id > 0
-        else:
-            assert id < 0
-        # We are double-deferring here so that we only start writing data to
-        # our client _after_ they have processed our ACK.
-        tpt = VirtualTransport(self, id, self.service._bootstrapFactory, False)
-
-
-        return dict(__transport__=tpt)
-
-    Virtual.responder(_virtual)
-
-
-    # Client/Support methods.
-
-    def attemptConnectionMethods(self, methods, connectionID, From, to,
-                                 protocolName, protocolFactory):
-        attemptObjects = []
-        for meth in methods:
-            atts = meth.attempt(self, connectionID, From, to,
-                                protocolName, protocolFactory)
-            attemptObjects.extend(atts)
-
-        attemptDeferreds = [att.startAttempt() for att in attemptObjects]
-
-        d = defer.DeferredList(attemptDeferreds,
-                              fireOnOneCallback=True,
-                              fireOnOneErrback=False)
-        def dontLogThat(e):
-            e.trap(error.ConnectionLost, error.ConnectionDone)
-
-        for attDef in attemptDeferreds:
-            attDef.addErrback(dontLogThat)
-
-        def _unfortunate_defer_hack(results):
-            #Do you see what you've made me become?
-            if isinstance(results, tuple):
-                stuff = [(False, None)] * len(attemptObjects)
-                stuff[results[1]] = (True, results[0])
-                return stuff
-            return results
-
-
-        def gotResults(results):
-            theResult = None
-            anyResult = False
-            for index, (success, result) in enumerate(results):
-                if success:
-                    # woohoo!  home free.
-                    # XXX Cancel outstanding attempts, maybe.  They'll fail anyway,
-                    # because the factory will return None from buildProtocol().
-                    theResult = result
-                    anyResult = True
-                else:
-                    attemptObjects[index].cancel()
-            if anyResult:
-                # theResult will be a SeparateConnectionTransport
-                return theResult.subProtocol
-            else:
-                reason = Failure(AttemptsFailed([fobj for (f, fobj) in results]))
-                return reason
-
-        d.addCallback(_unfortunate_defer_hack)
-        d.addCallback(gotResults)
-        return d
-
-
-    def listen(self, fromAddress, protocols, serverDescription):
-        return self.callRemote(
-            Listen, From=fromAddress,
-            protocols=protocols, description=serverDescription)
-
-
-    def connect(self, From, to,
-                protocolName, clientFactory,
-                chooser):
-        """
-        Issue an INBOUND command, creating a virtual connection to the peer,
-        given identifying information about the endpoint to connect to, and a
-        protocol factory.
-
-        @param clientFactory: a *Client* ProtocolFactory instance which will
-        generate a protocol upon connect.
-
-        @return: a Deferred which fires with the protocol instance that was
-        connected, or fails with AttemptsFailed if the connection was not
-        possible.
-        """
-
-        publicIP = self._determinePublicIP()
-
-        A = dict(From=From,
-                 to=to,
-                 protocol=protocolName)
-
-        if self.service.dispatcher is not None:
-            # tell them exactly where they can shove it
-            A['udp_source'] = (publicIP,
-                               self.service.sharedUDPPortnum)
-        else:
-            # don't tell them because we don't know
-            log.msg("dispatcher unavailable when connecting")
-
-        D = self.callRemote(Inbound, **A)
-
-        def _connected(answer):
-            listenersD = defer.maybeDeferred(chooser, answer['listeners'])
-            def gotListeners(listeners):
-                allConnectionAttempts = []
-                for listener in listeners:
-                    d = self.attemptConnectionMethods(
-                        listener['methods'],
-                        listener['id'],
-                        From, to,
-                        protocolName, clientFactory,
-                        )
-                    allConnectionAttempts.append(d)
-                return defer.DeferredList(allConnectionAttempts)
-            listenersD.addCallback(gotListeners)
-            def finishedAllAttempts(results):
-                succeededAny = False
-                failures = []
-                if not results:
-                    return Failure(NoAttemptsMade(
-                            "there was no available path for connections "
-                            "(%r->%r/%s)" % (From, to, protocolName)))
-                for succeeded, result in results:
-                    if succeeded:
-                        succeededAny = True
-                        randomConnection = result
-                        break
-                    else:
-                        failures.append(result)
-                if not succeededAny:
-                    return Failure(AttemptsFailed(
-                            [failure.getBriefTraceback() for failure in failures]))
-
-                # XXX TODO: this connection is really random; connectQ2Q should
-                # not return one of the connections it's made, put it into your
-                # protocol's connectionMade handler
-
-                return randomConnection
-
-            return listenersD.addCallback(finishedAllAttempts)
-        return D.addCallback(_connected)
-
-
-class SeparateConnectionTransport(object):
-    def __init__(self,
-                 service,
-                 subProtocol,
-                 q2qhost,
-                 q2qpeer,
-                 protocolName,
-                 connectionEstablishedDeferred=None):
-        self.service = service
-        self.subProtocol = subProtocol
-        self.q2qhost = q2qhost
-        self.q2qpeer = q2qpeer
-        self.protocolName = protocolName
-        self.connectionEstablishedDeferred = connectionEstablishedDeferred
-
-    subProtocol = None
-    q2qhost = None
-    q2qpeer = None
-    protocolName = 'unknown'
-
-    # ITransport
-    disconnecting = property(lambda self: self.transport.disconnecting)
-
-    # IQ2QTransport
-
-    def getQ2QHost(self):
-        return self.q2qhost
-
-    def getQ2QPeer(self):
-        return self.q2qpeer
-
-    def makeConnection(self, tpt):
-        self.transport = tpt
-        self.service.subConnections.append(self)
-        self.subProtocol.makeConnection(self)
-        if self.connectionEstablishedDeferred is not None:
-            self.connectionEstablishedDeferred.callback(self)
-
-    def getPeer(self):
-        return Q2QTransportAddress(self.getQ2QPeer(),
-                                   self.transport.getPeer(),
-                                   self.protocolName)
-
-    def getHost(self):
-        return Q2QTransportAddress(self.getQ2QHost(),
-                                   self.transport.getHost(),
-                                   self.protocolName)
-
-    def dataReceived(self, data):
-        self.subProtocol.dataReceived(data)
-
-    def write(self, data):
-        self.transport.write(data)
-
-    def writeSequence(self, data):
-        self.transport.writeSequence(data)
-
-    def registerProducer(self, producer, streaming):
-        self.transport.registerProducer(producer, streaming)
-
-    def unregisterProducer(self):
-        self.transport.unregisterProducer()
-
-    def loseConnection(self):
-        self.transport.loseConnection()
-
-    def connectionLost(self, reason):
-        self.service.subConnections.remove(self)
-        if self.subProtocol is not None:
-            self.subProtocol.connectionLost(reason)
-            self.subProtocol = None
-
-class WhoAmI(Command):
-    commandName = 'Who-Am-I'
-
-    response = [
-        ('address', HostPort()),
-        ]
-
-class RetrieveConnection(ProtocolSwitchCommand):
-    commandName = 'Retrieve-Connection'
-
-    arguments = [
-        ('identifier', String()),
-        ]
-
-    fatalErrors = {KeyError: "NoSuchConnection"}
-
-class Q2QBootstrap(AMP):
-    def __init__(self, connIdentifier=None, protoFactory=None):
-        AMP.__init__(self)
-        assert connIdentifier is None or isinstance(connIdentifier, (str))
-        self.connIdentifier = connIdentifier
-        self.protoFactory = protoFactory
-
-    def connectionMade(self):
-        if self.connIdentifier is not None:
-            def swallowKnown(err):
-                err.trap(error.ConnectionDone, KeyError)
-            self.retrieveConnection(self.connIdentifier, self.protoFactory).addErrback(swallowKnown)
-
-    def whoami(self):
-        """Return a Deferred which fires with a 2-tuple of (dotted quad ip, port
-        number).
-        """
-        def cbWhoAmI(result):
-            return result['address']
-        return self.callRemote(WhoAmI).addCallback(cbWhoAmI)
-
-
-    def _whoami(self):
-        peer = self.transport.getPeer()
-        return {
-            'address': (peer.host, peer.port),
-            }
-    WhoAmI.responder(_whoami)
-
-
-    def retrieveConnection(self, identifier, factory):
-        return self.callRemote(RetrieveConnection, factory, identifier=identifier)
-
-
-    def _retrieveConnection(self, identifier):
-        listenerInfo = self.service.lookupListener(identifier)
-        if listenerInfo is None:
-            raise KeyError(identifier)
-        else:
-            proto = listenerInfo.protocolFactory.buildProtocol(listenerInfo.From)
-            return SeparateConnectionTransport(
-                    self.service,
-                    proto,
-                    listenerInfo.to,
-                    listenerInfo.From,
-                    listenerInfo.protocolName)
-
-    RetrieveConnection.responder(_retrieveConnection)
-
-
-
-class Q2QBootstrapFactory(protocol.Factory):
-    protocol = Q2QBootstrap
-
-    def __init__(self, service):
-        self.service = service
-
-    def buildProtocol(self, addr):
-        q2etc = protocol.Factory.buildProtocol(self, addr)
-        q2etc.service = self.service
-        return q2etc
-
-class VirtualTransport(subproducer.SubProducer):
-    implements(interfaces.IProducer, interfaces.ITransport, interfaces.IConsumer)
-    disconnecting = False
-
-    def __init__(self, q2q, connectionID, protocolFactory, isClient):
-        """
-        @param q2q: a Q2Q Protocol instance.
-
-        @param connectionID: an integer identifier, unique to the q2q instance
-        that I am wrapping (my underlying physical connection).
-
-        @param protocolFactory: an IProtocolFactory implementor which returns a
-        protocol instance for me to use.  I'll use it to build the protocol,
-        and if the 'client' flag is True, also use it to notify
-        connectionLost/connectionFailed.
-
-        @param isClient: a boolean describing whether my protocol is the
-        initiating half of this connection or not.
-        """
-        subproducer.SubProducer.__init__(self, q2q)
-        self.q2q = q2q
-
-        self.id = connectionID
-        self.isClient = isClient
-        self.q2q.connections[self.id] = self
-        self.protocolFactory = protocolFactory
-
-    protocol = None
-
-    def startProtocol(self):
-        self.protocol = self.protocolFactory.buildProtocol(self.getPeer())
-        self.protocol.makeConnection(self)
-        return self.protocol
-
-    def pauseProducing(self):
-        self.q2q.callRemote(Choke, id=self.id)
-
-    def resumeProducing(self):
-        self.q2q.callRemote(Unchoke, id=self.id)
-
-    def writeSequence(self, iovec):
-        self.write(''.join(iovec))
-
-    def loseConnection(self):
-        if self.disconnecting:
-            # print 'omg wtf loseConnection!???!'
-            return
-        self.disconnecting = True
-        d = self.q2q.callRemoteString('close', id=str(self.id))
-        def cbClosed(ignored):
-            self.connectionLost(Failure(CONNECTION_DONE))
-        def ebClosed(reason):
-            if self.id in self.q2q.connections:
-                self.connectionLost(reason)
-            elif not reason.check(error.ConnectionDone):
-                # Anything but a ConnectionDone (or similar things, perhaps)
-                # is fishy.  Like an IndexError, that'd be wacko.  But a
-                # ConnectionDone when self.id is already out of the Q2Q's
-                # connections mapping means the connection was closed after
-                # we thought it was supposed to be closed.  No harm there.
-                log.err(reason, "Close virtual #%d failed" % (self.id,))
-        d.addCallbacks(cbClosed, ebClosed)
-
-
-    def connectionLost(self, reason):
-        del self.q2q.connections[self.id]
-        if self.protocol is not None:
-            self.protocol.connectionLost(reason)
-        if self.isClient:
-            self.protocolFactory.clientConnectionLost(None, reason)
-
-
-    def dataReceived(self, data):
-        try:
-            self.protocol.dataReceived(data)
-        except:
-            # XXX: unconditionally logging errors from user code makes it hard
-            # to write tests, and is not always the right thing to do.  we
-            # should revamp Twisted to have some kind of control over this
-            # behavior, and add that control back in to this code path as well
-            # (although logging exceptions from dataReceived is _by default_
-            # certainly the right thing to do)  --glyph+exarkun
-            reason = Failure()
-            log.err(reason)
-            self.connectionLost(reason)
-
-    def write(self, data):
-        self.q2q.callRemoteString(
-            'write', False, body=data, id=str(self.id))
-
-    def getHost(self):
-        return VirtualTransportAddress(self.q2q.transport.getHost())
-
-    def getPeer(self):
-        return VirtualTransportAddress(self.q2q.transport.getPeer())
-
-
-_counter = 0
-def _nextJuiceLog():
-    global _counter
-    try:
-        return str(_counter)
-    finally:
-        _counter = _counter + 1
-
-class DefaultQ2QAvatar:
-    implements(ivertex.IQ2QUser)
-
-    def __init__(self, username, domain):
-        self.username = username
-        self.domain = domain
-
-    def signCertificateRequest(self, certificateRequest,
-                               domainCert, suggestedSerial):
-        keyz = certificateRequest.getSubject().keys()
-        if keyz != ['commonName']:
-            raise BadCertificateRequest(
-                "Don't know how to verify fields other than CN: " +
-                repr(keyz))
-        newCert = domainCert.signRequestObject(
-            certificateRequest,
-            suggestedSerial)
-        log.msg('signing certificate for user %s@%s: %s' % (
-                self.username, self.domain, newCert.digest()))
-        return newCert
-
-
-
-class DefaultCertificateStore:
-
-    implements(ICredentialsChecker, IRealm)
-
-    credentialInterfaces = [IUsernamePassword]
-
-    def requestAvatar(self, avatarId, mind, interface):
-        assert interface is ivertex.IQ2QUser, (
-            "default certificate store only supports one interface")
-        return interface, DefaultQ2QAvatar(*avatarId.split("@")), lambda : None
-
-    def requestAvatarId(self, credentials):
-        username, domain = credentials.username.split("@")
-        pw = self.users.get((domain, username))
-        if pw is None:
-            return defer.fail(UnauthorizedLogin())
-        def _(passwordIsCorrect):
-            if passwordIsCorrect:
-                return username + '@' + domain
-            else:
-                raise UnauthorizedLogin()
-        return defer.maybeDeferred(
-            credentials.checkPassword, pw).addCallback(_)
-
-    def __init__(self):
-        self.remoteStore = {}
-        self.localStore = {}
-        self.users = {}
-
-    def getSelfSignedCertificate(self, domainName):
-        return defer.maybeDeferred(self.remoteStore.__getitem__, domainName)
-
-    def addUser(self, domain, username, privateSecret):
-        self.users[domain, username] = privateSecret
-
-    def checkUser(self, domain, username, privateSecret):
-        if self.users.get((domain, username)) != privateSecret:
-            return defer.fail(KeyError())
-        return defer.succeed(True)
-
-    def storeSelfSignedCertificate(self, domainName, mainCert):
-        """
-
-        @return: a Deferred which will fire when the certificate has been
-        stored successfully.
-        """
-        assert not isinstance(mainCert, str)
-        return defer.maybeDeferred(self.remoteStore.__setitem__, domainName, mainCert)
-
-    def getPrivateCertificate(self, domainName):
-        """
-
-        @return: a PrivateCertificate instance, e.g. a certificate including a
-        private key, for 'domainName'.
-        """
-        return self.localStore[domainName]
-
-
-    def genSerial(self, name):
-        return abs(struct.unpack('!i', md5(name).digest()[:4])[0])
-
-    def addPrivateCertificate(self, subjectName, existingCertificate=None):
-        """
-        Add a PrivateCertificate object to this store for this subjectName.
-
-        If existingCertificate is None, add a new self-signed certificate.
-        """
-        if existingCertificate is None:
-            assert '@' not in subjectName, "Don't self-sign user certs!"
-            mainDN = DistinguishedName(commonName=subjectName)
-            mainKey = KeyPair.generate()
-            mainCertReq = mainKey.certificateRequest(mainDN)
-            mainCertData = mainKey.signCertificateRequest(mainDN, mainCertReq,
-                                                          lambda dn: True,
-                                                          self.genSerial(subjectName))
-            mainCert = mainKey.newCertificate(mainCertData)
-        else:
-            mainCert = existingCertificate
-        self.localStore[subjectName] = mainCert
-
-import os
-
-class _pemmap(object):
-    def __init__(self, pathname, certclass):
-        self.pathname = pathname
-        try:
-            os.makedirs(pathname)
-        except (OSError, IOError):
-            pass
-        self.certclass = certclass
-
-    def file(self, name, mode):
-        try:
-            return file(os.path.join(self.pathname, name)+'.pem', mode)
-        except IOError, ioe:
-            raise KeyError(name, ioe)
-
-    def __setitem__(self, key, cert):
-        kn = cert.getSubject().commonName
-        assert kn == key
-        self.file(kn, 'wb').write(cert.dumpPEM())
-
-    def __getitem__(self, cn):
-        return self.certclass.loadPEM(self.file(cn, 'rb').read())
-
-    def iteritems(self):
-        files = os.listdir(self.pathname)