1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
# -*- test-case-name: twisted.words.test.test_jabberjid -*-
#
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Jabber Identifier support.
This module provides an object to represent Jabber Identifiers (JIDs) and
parse string representations into them with proper checking for illegal
characters, case folding and canonicalisation through
L{stringprep<twisted.words.protocols.jabber.xmpp_stringprep>}.
"""
from typing import Dict, Tuple, Union
from twisted.words.protocols.jabber.xmpp_stringprep import (
nameprep,
nodeprep,
resourceprep,
)
class InvalidFormat(Exception):
"""
The given string could not be parsed into a valid Jabber Identifier (JID).
"""
def parse(jidstring: str) -> Tuple[Union[str, None], str, Union[str, None]]:
"""
Parse given JID string into its respective parts and apply stringprep.
@param jidstring: string representation of a JID.
@type jidstring: L{str}
@return: tuple of (user, host, resource), each of type L{str} as
the parsed and stringprep'd parts of the given JID. If the
given string did not have a user or resource part, the respective
field in the tuple will hold L{None}.
@rtype: L{tuple}
"""
user = None
host = None
resource = None
# Search for delimiters
user_sep = jidstring.find("@")
res_sep = jidstring.find("/")
if user_sep == -1:
if res_sep == -1:
# host
host = jidstring
else:
# host/resource
host = jidstring[0:res_sep]
resource = jidstring[res_sep + 1 :] or None
else:
if res_sep == -1:
# user@host
user = jidstring[0:user_sep] or None
host = jidstring[user_sep + 1 :]
else:
if user_sep < res_sep:
# user@host/resource
user = jidstring[0:user_sep] or None
host = jidstring[user_sep + 1 : user_sep + (res_sep - user_sep)]
resource = jidstring[res_sep + 1 :] or None
else:
# host/resource (with an @ in resource)
host = jidstring[0:res_sep]
resource = jidstring[res_sep + 1 :] or None
return prep(user, host, resource)
def prep(
user: Union[str, None], host: str, resource: Union[str, None]
) -> Tuple[Union[str, None], str, Union[str, None]]:
"""
Perform stringprep on all JID fragments.
@param user: The user part of the JID.
@type user: L{str}
@param host: The host part of the JID.
@type host: L{str}
@param resource: The resource part of the JID.
@type resource: L{str}
@return: The given parts with stringprep applied.
@rtype: L{tuple}
"""
if user:
try:
user = nodeprep.prepare(str(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(str(host))
except UnicodeError:
raise InvalidFormat("Invalid character in hostname")
if resource:
try:
resource = resourceprep.prepare(str(resource))
except UnicodeError:
raise InvalidFormat("Invalid character in resource")
else:
resource = None
return (user, host, resource)
__internJIDs: Dict[str, "JID"] = {}
def internJID(jidstring):
"""
Return interned JID.
@rtype: L{JID}
"""
if jidstring in __internJIDs:
return __internJIDs[jidstring]
else:
j = JID(jidstring)
__internJIDs[jidstring] = j
return j
class JID:
"""
Represents a stringprep'd Jabber ID.
JID objects are hashable so they can be used in sets and as keys in
dictionaries.
"""
def __init__(
self,
str: Union[str, None] = None,
tuple: Union[Tuple[Union[str, None], str, Union[str, None]], None] = None,
):
if str:
user, host, res = parse(str)
elif tuple:
user, host, res = prep(*tuple)
else:
raise RuntimeError(
"You must provide a value for either 'str' or 'tuple' arguments."
)
self.user = user
self.host = host
self.resource = res
def userhost(self):
"""
Extract the bare JID as a unicode string.
A bare JID does not have a resource part, so this returns either
C{user@host} or just C{host}.
@rtype: L{str}
"""
if self.user:
return f"{self.user}@{self.host}"
else:
return self.host
def userhostJID(self):
"""
Extract the bare JID.
A bare JID does not have a resource part, so this returns a
L{JID} object representing either C{user@host} or just C{host}.
If the object this method is called upon doesn't have a resource
set, it will return itself. Otherwise, the bare JID object will
be created, interned using L{internJID}.
@rtype: L{JID}
"""
if self.resource:
return internJID(self.userhost())
else:
return self
def full(self):
"""
Return the string representation of this JID.
@rtype: L{str}
"""
if self.user:
if self.resource:
return f"{self.user}@{self.host}/{self.resource}"
else:
return f"{self.user}@{self.host}"
else:
if self.resource:
return f"{self.host}/{self.resource}"
else:
return self.host
def __eq__(self, other: object) -> bool:
"""
Equality comparison.
L{JID}s compare equal if their user, host and resource parts all
compare equal. When comparing against instances of other types, it
uses the default comparison.
"""
if isinstance(other, JID):
return (
self.user == other.user
and self.host == other.host
and self.resource == other.resource
)
else:
return NotImplemented
def __hash__(self):
"""
Calculate hash.
L{JID}s with identical constituent user, host and resource parts have
equal hash values. In combination with the comparison defined on JIDs,
this allows for using L{JID}s in sets and as dictionary keys.
"""
return hash((self.user, self.host, self.resource))
def __unicode__(self):
"""
Get unicode representation.
Return the string representation of this JID as a unicode string.
@see: L{full}
"""
return self.full()
__str__ = __unicode__
def __repr__(self) -> str:
"""
Get object representation.
Returns a string that would create a new JID object that compares equal
to this one.
"""
return "JID(%r)" % self.full()
|
