← Back to branch summary

~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to twisted/words/protocols/jabber/jid.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-17 14:52:35 UTC
  • mfrom: (1.1.5 upstream) (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20070117145235-btmig6qfmqfen0om
Tags: 2.5.0-0ubuntu1
New upstream version, compatible with python2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
twisted/words/protocols/jabber/jid.py
 
1
# -*- test-case-name: twisted.words.test.test_jabberjid -*-
 
2
#
 
3
# Copyright (c) 2001-2005 Twisted Matrix Laboratories.
 
4
# See LICENSE for details.
 
5
 
 
6
from twisted.internet import reactor, protocol, defer
 
7
from twisted.words.xish import domish, utility
 
8
from twisted.words.protocols.jabber.xmpp_stringprep import nodeprep, resourceprep, nameprep
 
9
import string
 
10
 
 
11
class InvalidFormat(Exception):
 
12
    pass
 
13
 
 
14
def parse(jidstring):
 
15
    user = None
 
16
    server = None
 
17
    resource = None
 
18
 
 
19
    # Search for delimiters
 
20
    user_sep = jidstring.find("@")
 
21
    res_sep  = jidstring.find("/")
 
22
 
 
23
    if user_sep == -1:        
 
24
        if res_sep == -1:
 
25
            # host
 
26
            server = jidstring
 
27
        else:
 
28
            # host/resource
 
29
            server = jidstring[0:res_sep]
 
30
            resource = jidstring[res_sep + 1:] or None
 
31
    else:
 
32
        if res_sep == -1:
 
33
            # user@host
 
34
            user = jidstring[0:user_sep] or None
 
35
            server = jidstring[user_sep + 1:]
 
36
        else:
 
37
            if user_sep < res_sep:
 
38
                # user@host/resource
 
39
                user = jidstring[0:user_sep] or None
 
40
                server = jidstring[user_sep + 1:user_sep + (res_sep - user_sep)]
 
41
                resource = jidstring[res_sep + 1:] or None
 
42
            else:
 
43
                # server/resource (with an @ in resource)
 
44
                server = jidstring[0:res_sep]
 
45
                resource = jidstring[res_sep + 1:] or None
 
46
 
 
47
    return prep(user, server, resource)
 
48
 
 
49
def prep(user, server, resource):
 
50
    """ Perform stringprep on all JID fragments """
 
51
 
 
52
    if user:
 
53
        try:
 
54
            user = nodeprep.prepare(unicode(user))
 
55
        except UnicodeError:
 
56
            raise InvalidFormat, "Invalid character in username"
 
57
    else:
 
58
        user = None
 
59
 
 
60
    if not server:
 
61
        raise InvalidFormat, "Server address required."
 
62
    else:
 
63
        try:
 
64
            server = nameprep.prepare(unicode(server))
 
65
        except UnicodeError:
 
66
            raise InvalidFormat, "Invalid character in hostname"
 
67
 
 
68
    if resource:
 
69
        try:
 
70
            resource = resourceprep.prepare(unicode(resource))
 
71
        except UnicodeError:
 
72
            raise InvalidFormat, "Invalid character in resource"
 
73
    else:
 
74
        resource = None
 
75
 
 
76
    return (user, server, resource)
 
77
 
 
78
__internJIDs = {}
 
79
 
 
80
def internJID(str):
 
81
    """ Return interned JID.
 
82
 
 
83
    Assumes C{str} is stringprep'd.
 
84
    """
 
85
 
 
86
    if str in __internJIDs:
 
87
        return __internJIDs[str]
 
88
    else:
 
89
        j = JID(str)
 
90
        __internJIDs[str] = j
 
91
        return j
 
92
 
 
93
class JID:
 
94
    """ Represents a stringprep'd Jabber ID.
 
95
 
 
96
    Note that it is assumed that the attributes C{host}, C{user} and
 
97
    C{resource}, when set individually, have been properly stringprep'd.
 
98
    """
 
99
 
 
100
    def __init__(self, str = None, tuple = None):
 
101
        assert (str or tuple)
 
102
        
 
103
        if str:
 
104
            user, host, res = parse(str)
 
105
        else:
 
106
            user, host, res = prep(*tuple)
 
107
 
 
108
        self.host = host
 
109
        self.user = user
 
110
        self.resource = res
 
111
            
 
112
    def userhost(self):
 
113
        if self.user:
 
114
            return "%s@%s" % (self.user, self.host)
 
115
        else:
 
116
            return self.host
 
117
 
 
118
    def userhostJID(self):
 
119
        if self.resource:
 
120
            if "_uhjid" not in self.__dict__:
 
121
                self._uhjid = internJID(self.userhost())
 
122
            return self._uhjid
 
123
        else:
 
124
            return self
 
125
 
 
126
    def full(self):
 
127
        if self.user:
 
128
            if self.resource:
 
129
                return "%s@%s/%s" % (self.user, self.host, self.resource)
 
130
            else:
 
131
                return "%s@%s" % (self.user, self.host)
 
132
        else:
 
133
            if self.resource:
 
134
                return "%s/%s" % (self.host, self.resource)
 
135
            else:
 
136
                return self.host
 
137
 
 
138
    def __eq__(self, other):
 
139
        return (self.user == other.user and
 
140
                self.host == other.host and
 
141
                self.resource == other.resource)
 
142
 
 
143
    def __ne__(self, other):
 
144
        return not (self.user == other.user and
 
145
                    self.host == other.host and
 
146
                    self.resource == other.resource)