Example #1
0
def prep(user, server, resource):
    """ Stringprep, backported from Twisted 2.0 """

    if user:
        try:
            user = nodeprep.prepare(unicode(user))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in username"
    else:
        user = None

    if not server:
        raise InvalidFormat, "Server address required."
    else:
        try:
            server = nameprep.prepare(unicode(server))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in resource"

    if resource:
        try:
            resource = resourceprep.prepare(unicode(resource))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in resource"
    else:
        resource = None

    return (user, server, resource)
Example #2
0
def prep(user, server, resource):
    """ Perform stringprep on all JID fragments """

    if user:
        try:
            user = nodeprep.prepare(unicode(user))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in username"
    else:
        user = None

    if not server:
        raise InvalidFormat, "Server address required."
    else:
        try:
            server = nameprep.prepare(unicode(server))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in hostname"

    if resource:
        try:
            resource = resourceprep.prepare(unicode(resource))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in resource"
    else:
        resource = None

    return (user, server, resource)
Example #3
0
File: groups.py Project: monoid/w4
    def join(self, chan, nickname):
        # Check nick validity
        try:
            nickname = resourceprep.prepare(nickname.decode('utf-8'))
            if not nickname or not VALID_NICK_REGEX.match(nickname):
                raise InvalidNickException(nick=nickname,
                                           xmpp=('urn:ietf:params:xml:ns:xmpp-stanzas', 'jid-malformed'))
            if len(nickname) > 18:
                raise InvalidNickException(nick=nickname,
                                           reason="Nickname too long",
                                           xmpp=('urn:ietf:params:xml:ns:xmpp-stanzas', 'jid-malformed'))
        except UnicodeError:
            raise InvalidNickException(nick=nickname)


        if self.public:
            if nickname in self.channels:
                if self.channels[nickname].channel == chan:
                    chan.sendSecondaryInfo(self)
                    return True
                else:
                    raise NickConflictException()

            # Leave group if the channel have been logged before with
            # different names
            if self.name in chan.groups:
                if chan.groups[self.name] != nickname:
                    self.leave(chan)

            chan.groups[self.name] = self.channels[nickname] = MUCUser(self, nickname, chan)

            chan.sendInitialInfo(self)

            self.broadcast({
                'cmd': 'join',
                'user': nickname,
                'except': nickname
            })
            return True
        else:
            raise RegistrationRequiredException()
Example #4
0
def prep(user, host, resource):
    """
    Perform stringprep on all JID fragments.

    @param user: The user part of the JID.
    @type user: C{unicode}
    @param host: The host part of the JID.
    @type host: C{unicode}
    @param resource: The resource part of the JID.
    @type resource: C{unicode}
    @return: The given parts with stringprep applied.
    @rtype: C{tuple}
    """

    if user:
        try:
            user = nodeprep.prepare(unicode(user))
        except UnicodeError:
            raise InvalidFormat("Invalid character in username")
    else:
        user = None

    if not host:
        raise InvalidFormat("Server address required.")
    else:
        try:
            host = nameprep.prepare(unicode(host))
        except UnicodeError:
            raise InvalidFormat("Invalid character in hostname")

    if resource:
        try:
            resource = resourceprep.prepare(unicode(resource))
        except UnicodeError:
            raise InvalidFormat("Invalid character in resource")
    else:
        resource = None

    return (user, host, resource)
Example #5
0
File: jid.py Project: 0004c/VTK
def prep(user, host, resource):
    """
    Perform stringprep on all JID fragments.

    @param user: The user part of the JID.
    @type user: C{unicode}
    @param host: The host part of the JID.
    @type host: C{unicode}
    @param resource: The resource part of the JID.
    @type resource: C{unicode}
    @return: The given parts with stringprep applied.
    @rtype: C{tuple}
    """

    if user:
        try:
            user = nodeprep.prepare(unicode(user))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in username"
    else:
        user = None

    if not host:
        raise InvalidFormat, "Server address required."
    else:
        try:
            host = nameprep.prepare(unicode(host))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in hostname"

    if resource:
        try:
            resource = resourceprep.prepare(unicode(resource))
        except UnicodeError:
            raise InvalidFormat, "Invalid character in resource"
    else:
        resource = None

    return (user, host, resource)
    def testResourcePrep(self):
        self.assertEqual(resourceprep.prepare("resource"), "resource")
        self.assertNotEqual(resourceprep.prepare("Resource"), "resource")
        self.assertEqual(resourceprep.prepare(" "), " ")

        self.assertEqual(resourceprep.prepare("Henry \u2163"), "Henry IV")
        self.assertEqual(
            resourceprep.prepare("foo\xad\u034f\u1806\u180b"
                                 "bar\u200b\u2060"
                                 "baz\ufe00\ufe08\ufe0f\ufeff"),
            "foobarbaz",
        )
        self.assertEqual(resourceprep.prepare("\u00a0"), " ")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u1680")
        self.assertEqual(resourceprep.prepare("\u2000"), " ")
        self.assertEqual(resourceprep.prepare("\u200b"), "")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u0010\u007f")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u0085")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u180e")
        self.assertEqual(resourceprep.prepare("\ufeff"), "")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\uf123")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U000f1234")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U0010f234")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U0008fffe")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U0010ffff")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\udf42")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\ufffd")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u2ff5")
        self.assertEqual(resourceprep.prepare("\u0341"), "\u0301")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u200e")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u202a")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U000e0001")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U000e0042")
        self.assertRaises(UnicodeError, resourceprep.prepare, "foo\u05bebar")
        self.assertRaises(UnicodeError, resourceprep.prepare, "foo\ufd50bar")
        # self.assertEqual(resourceprep.prepare(u'foo\ufb38bar'),
        #                  u'foo\u064ebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, "\u06271")
        self.assertEqual(resourceprep.prepare("\u06271\u0628"),
                         "\u06271\u0628")
        self.assertRaises(UnicodeError, resourceprep.prepare, "\U000e0002")
    def testResourcePrep(self):
        self.assertEqual(resourceprep.prepare(u'resource'), u'resource')
        self.assertNotEqual(resourceprep.prepare(u'Resource'), u'resource')
        self.assertEqual(resourceprep.prepare(u' '), u' ')

        self.assertEqual(resourceprep.prepare(u'Henry \u2163'), u'Henry IV')
        self.assertEqual(resourceprep.prepare(u'foo\xad\u034f\u1806\u180b'
                                               u'bar\u200b\u2060'
                                               u'baz\ufe00\ufe08\ufe0f\ufeff'),
                          u'foobarbaz')
        self.assertEqual(resourceprep.prepare(u'\u00a0'), u' ')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u1680')
        self.assertEqual(resourceprep.prepare(u'\u2000'), u' ')
        self.assertEqual(resourceprep.prepare(u'\u200b'), u'')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u0010\u007f')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u0085')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u180e')
        self.assertEqual(resourceprep.prepare(u'\ufeff'), u'')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\uf123')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000f1234')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0010f234')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0008fffe')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0010ffff')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\udf42')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\ufffd')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u2ff5')
        self.assertEqual(resourceprep.prepare(u'\u0341'), u'\u0301')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u200e')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u202a')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0001')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0042')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'foo\u05bebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'foo\ufd50bar')
        #self.assertEqual(resourceprep.prepare(u'foo\ufb38bar'),
        #                  u'foo\u064ebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u06271')
        self.assertEqual(resourceprep.prepare(u'\u06271\u0628'),
                          u'\u06271\u0628')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0002')
    def testResourcePrep(self):
        self.assertEqual(resourceprep.prepare(u'resource'), u'resource')
        self.assertNotEquals(resourceprep.prepare(u'Resource'), u'resource')
        self.assertEqual(resourceprep.prepare(u' '), u' ')

        self.assertEqual(resourceprep.prepare(u'Henry \u2163'), u'Henry IV')
        self.assertEqual(resourceprep.prepare(u'foo\xad\u034f\u1806\u180b'
                                               u'bar\u200b\u2060'
                                               u'baz\ufe00\ufe08\ufe0f\ufeff'),
                          u'foobarbaz')
        self.assertEqual(resourceprep.prepare(u'\u00a0'), u' ')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u1680')
        self.assertEqual(resourceprep.prepare(u'\u2000'), u' ')
        self.assertEqual(resourceprep.prepare(u'\u200b'), u'')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u0010\u007f')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u0085')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u180e')
        self.assertEqual(resourceprep.prepare(u'\ufeff'), u'')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\uf123')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000f1234')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0010f234')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0008fffe')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U0010ffff')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\udf42')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\ufffd')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u2ff5')
        self.assertEqual(resourceprep.prepare(u'\u0341'), u'\u0301')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u200e')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u202a')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0001')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0042')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'foo\u05bebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'foo\ufd50bar')
        #self.assertEqual(resourceprep.prepare(u'foo\ufb38bar'),
        #                  u'foo\u064ebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\u06271')
        self.assertEqual(resourceprep.prepare(u'\u06271\u0628'),
                          u'\u06271\u0628')
        self.assertRaises(UnicodeError, resourceprep.prepare, u'\U000e0002')
    def testResourcePrep(self):
        self.assertEquals(resourceprep.prepare(u"resource"), u"resource")
        self.assertNotEquals(resourceprep.prepare(u"Resource"), u"resource")
        self.assertEquals(resourceprep.prepare(u" "), u" ")

        if crippled:
            return

        self.assertEquals(resourceprep.prepare(u"Henry \u2163"), u"Henry IV")
        self.assertEquals(
            resourceprep.prepare(u"foo\xad\u034f\u1806\u180b" u"bar\u200b\u2060" u"baz\ufe00\ufe08\ufe0f\ufeff"),
            u"foobarbaz",
        )
        self.assertEquals(resourceprep.prepare(u"\u00a0"), u" ")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u1680")
        self.assertEquals(resourceprep.prepare(u"\u2000"), u" ")
        self.assertEquals(resourceprep.prepare(u"\u200b"), u"")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u0010\u007f")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u0085")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u180e")
        self.assertEquals(resourceprep.prepare(u"\ufeff"), u"")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\uf123")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U000f1234")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U0010f234")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U0008fffe")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U0010ffff")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\udf42")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\ufffd")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u2ff5")
        self.assertEquals(resourceprep.prepare(u"\u0341"), u"\u0301")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u200e")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u202a")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U000e0001")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U000e0042")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"foo\u05bebar")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"foo\ufd50bar")
        # self.assertEquals(resourceprep.prepare(u'foo\ufb38bar'),
        #                  u'foo\u064ebar')
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\u06271")
        self.assertEquals(resourceprep.prepare(u"\u06271\u0628"), u"\u06271\u0628")
        self.assertRaises(UnicodeError, resourceprep.prepare, u"\U000e0002")