404

[ Avaa Bypassed ]




Upload:

Command:

botdev@18.218.242.255: ~ $
# -*- test-case-name: twisted.web.
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
I am a virtual hosts implementation.
"""

from __future__ import division, absolute_import

# Twisted Imports
from twisted.python import roots
from twisted.web import resource


class VirtualHostCollection(roots.Homogenous):
    """Wrapper for virtual hosts collection.

    This exists for configuration purposes.
    """
    entityType = resource.Resource

    def __init__(self, nvh):
        self.nvh = nvh

    def listStaticEntities(self):
        return self.nvh.hosts.items()

    def getStaticEntity(self, name):
        return self.nvh.hosts.get(self)

    def reallyPutEntity(self, name, entity):
        self.nvh.addHost(name, entity)

    def delEntity(self, name):
        self.nvh.removeHost(name)


class NameVirtualHost(resource.Resource):
    """I am a resource which represents named virtual hosts.
    """

    default = None

    def __init__(self):
        """Initialize.
        """
        resource.Resource.__init__(self)
        self.hosts = {}

    def listStaticEntities(self):
        return resource.Resource.listStaticEntities(self) + [("Virtual Hosts", VirtualHostCollection(self))]

    def getStaticEntity(self, name):
        if name == "Virtual Hosts":
            return VirtualHostCollection(self)
        else:
            return resource.Resource.getStaticEntity(self, name)

    def addHost(self, name, resrc):
        """Add a host to this virtual host.

        This will take a host named `name', and map it to a resource
        `resrc'.  For example, a setup for our virtual hosts would be::

            nvh.addHost('divunal.com', divunalDirectory)
            nvh.addHost('www.divunal.com', divunalDirectory)
            nvh.addHost('twistedmatrix.com', twistedMatrixDirectory)
            nvh.addHost('www.twistedmatrix.com', twistedMatrixDirectory)
        """
        self.hosts[name] = resrc

    def removeHost(self, name):
        """Remove a host."""
        del self.hosts[name]

    def _getResourceForRequest(self, request):
        """(Internal) Get the appropriate resource for the given host.
        """
        hostHeader = request.getHeader(b'host')
        if hostHeader == None:
            return self.default or resource.NoResource()
        else:
            host = hostHeader.lower().split(b':', 1)[0]
        return (self.hosts.get(host, self.default)
                or resource.NoResource("host %s not in vhost map" % repr(host)))

    def render(self, request):
        """Implementation of resource.Resource's render method.
        """
        resrc = self._getResourceForRequest(request)
        return resrc.render(request)

    def getChild(self, path, request):
        """Implementation of resource.Resource's getChild method.
        """
        resrc = self._getResourceForRequest(request)
        if resrc.isLeaf:
            request.postpath.insert(0,request.prepath.pop(-1))
            return resrc
        else:
            return resrc.getChildWithDefault(path, request)

class _HostResource(resource.Resource):

    def getChild(self, path, request):
        if b':' in path:
            host, port = path.split(b':', 1)
            port = int(port)
        else:
            host, port = path, 80
        request.setHost(host, port)
        prefixLen = (3 + request.isSecure() + 4 + len(path) +
                     len(request.prepath[-3]))
        request.path = b'/' + b'/'.join(request.postpath)
        request.uri = request.uri[prefixLen:]
        del request.prepath[:3]
        return request.site.getResourceFor(request)


class VHostMonsterResource(resource.Resource):

    """
    Use this to be able to record the hostname and method (http vs. https)
    in the URL without disturbing your web site. If you put this resource
    in a URL http://foo.com/bar then requests to
    http://foo.com/bar/http/baz.com/something will be equivalent to
    http://foo.com/something, except that the hostname the request will
    appear to be accessing will be "baz.com". So if "baz.com" is redirecting
    all requests for to foo.com, while foo.com is inaccessible from the outside,
    then redirect and url generation will work correctly
    """
    def getChild(self, path, request):
        if path == b'http':
            request.isSecure = lambda: 0
        elif path == b'https':
            request.isSecure = lambda: 1
        return _HostResource()

Filemanager

Name Type Size Permission Actions
__pycache__ Folder 0755
_auth Folder 0755
test Folder 0755
__init__.py File 699 B 0644
_element.py File 5.81 KB 0644
_flatten.py File 15.54 KB 0644
_http2.py File 48 KB 0644
_newclient.py File 61.84 KB 0644
_responses.py File 3.57 KB 0644
_stan.py File 10.54 KB 0644
client.py File 74.26 KB 0644
demo.py File 554 B 0644
distrib.py File 11.45 KB 0644
domhelpers.py File 8.44 KB 0644
error.py File 12.49 KB 0644
guard.py File 630 B 0644
html.py File 1.52 KB 0644
http.py File 96.91 KB 0644
http_headers.py File 8.04 KB 0644
iweb.py File 24.97 KB 0644
microdom.py File 35.35 KB 0644
proxy.py File 9.6 KB 0644
resource.py File 12.8 KB 0644
rewrite.py File 1.81 KB 0644
script.py File 5.61 KB 0644
server.py File 25.86 KB 0644
static.py File 35.12 KB 0644
sux.py File 20.4 KB 0644
tap.py File 8.73 KB 0644
template.py File 17.14 KB 0644
twcgi.py File 11.08 KB 0644
util.py File 12.12 KB 0644
vhost.py File 4.36 KB 0644
wsgi.py File 21.04 KB 0644
xmlrpc.py File 19.66 KB 0644