1package de.gultsch.chat.xmpp;
2
3import java.io.IOException;
4import java.io.InputStream;
5import java.io.OutputStream;
6import java.math.BigInteger;
7import java.net.Socket;
8import java.net.UnknownHostException;
9import java.security.SecureRandom;
10import java.util.Hashtable;
11
12import javax.net.ssl.SSLSocket;
13import javax.net.ssl.SSLSocketFactory;
14
15import org.xmlpull.v1.XmlPullParserException;
16
17import android.os.PowerManager;
18import android.util.Log;
19import de.gultsch.chat.entities.Account;
20import de.gultsch.chat.utils.SASL;
21import de.gultsch.chat.xml.Element;
22import de.gultsch.chat.xml.Tag;
23import de.gultsch.chat.xml.XmlReader;
24import de.gultsch.chat.xml.TagWriter;
25
26public class XmppConnection implements Runnable {
27
28 protected Account account;
29 private static final String LOGTAG = "xmppService";
30
31 private PowerManager.WakeLock wakeLock;
32
33 private SecureRandom random = new SecureRandom();
34
35 private Socket socket;
36 private XmlReader tagReader;
37 private TagWriter tagWriter;
38
39 private boolean isTlsEncrypted = false;
40 private boolean isAuthenticated = false;
41 //private boolean shouldUseTLS = false;
42 private boolean shouldReConnect = true;
43 private boolean shouldBind = true;
44 private boolean shouldAuthenticate = true;
45 private Element streamFeatures;
46
47 private static final int PACKET_IQ = 0;
48 private static final int PACKET_MESSAGE = 1;
49 private static final int PACKET_PRESENCE = 2;
50
51 private Hashtable<String, OnIqPacketReceived> iqPacketCallbacks = new Hashtable<String, OnIqPacketReceived>();
52 private OnPresencePacketReceived presenceListener = null;
53 private OnIqPacketReceived unregisteredIqListener = null;
54 private OnMessagePacketReceived messageListener = null;
55
56 private String resource = null;
57
58 public XmppConnection(Account account, PowerManager pm) {
59 this.account = account;
60 wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
61 "XmppConnection");
62 tagReader = new XmlReader(wakeLock);
63 tagWriter = new TagWriter();
64 }
65
66 protected void connect() {
67 try {
68 socket = new Socket(account.getServer(), 5222);
69 Log.d(LOGTAG, "starting new socket");
70 OutputStream out = socket.getOutputStream();
71 tagWriter.setOutputStream(out);
72 InputStream in = socket.getInputStream();
73 tagReader.setInputStream(in);
74 tagWriter.beginDocument();
75 sendStartStream();
76 Tag nextTag;
77 while ((nextTag = tagReader.readTag()) != null) {
78 if (nextTag.isStart("stream")) {
79 processStream(nextTag);
80 } else {
81 Log.d(LOGTAG, "found unexpected tag: " + nextTag.getName());
82 return;
83 }
84 }
85 } catch (UnknownHostException e) {
86 Log.d(LOGTAG,account.getJid()+": error during connect. unknown host");
87 return;
88 } catch (IOException e) {
89 Log.d(LOGTAG, account.getJid()+": error during connect. io exception. falscher port?");
90 return;
91 } catch (XmlPullParserException e) {
92 Log.d(LOGTAG,"xml exception "+e.getMessage());
93 return;
94 }
95 }
96
97 @Override
98 public void run() {
99 while(shouldReConnect) {
100 connect();
101 try {
102 Thread.sleep(30000);
103 } catch (InterruptedException e) {
104 // TODO Auto-generated catch block
105 e.printStackTrace();
106 }
107 }
108 }
109
110 private void processStream(Tag currentTag) throws XmlPullParserException,
111 IOException {
112 Tag nextTag;
113 while (!(nextTag = tagReader.readTag()).isEnd("stream")) {
114 if (nextTag.isStart("error")) {
115 processStreamError(nextTag);
116 } else if (nextTag.isStart("features")) {
117 processStreamFeatures(nextTag);
118 } else if (nextTag.isStart("proceed")) {
119 switchOverToTls(nextTag);
120 } else if (nextTag.isStart("success")) {
121 isAuthenticated = true;
122 Log.d(LOGTAG,account.getJid()+": read success tag in stream. reset again");
123 tagReader.readTag();
124 tagReader.reset();
125 sendStartStream();
126 processStream(tagReader.readTag());
127 } else if (nextTag.isStart("iq")) {
128 processIq(nextTag);
129 } else if (nextTag.isStart("message")) {
130 processMessage(nextTag);
131 } else if (nextTag.isStart("presence")) {
132 processPresence(nextTag);
133 } else {
134 Log.d(LOGTAG, "found unexpected tag: " + nextTag.getName()
135 + " as child of " + currentTag.getName());
136 }
137 }
138 }
139
140 private Element processPacket(Tag currentTag, int packetType) throws XmlPullParserException, IOException {
141 Element element;
142 switch (packetType) {
143 case PACKET_IQ:
144 element = new IqPacket();
145 break;
146 case PACKET_MESSAGE:
147 element = new MessagePacket();
148 break;
149 case PACKET_PRESENCE:
150 element = new PresencePacket();
151 break;
152 default:
153 return null;
154 }
155 element.setAttributes(currentTag.getAttributes());
156 Tag nextTag = tagReader.readTag();
157 while(!nextTag.isEnd(element.getName())) {
158 if (!nextTag.isNo()) {
159 Element child = tagReader.readElement(nextTag);
160 element.addChild(child);
161 }
162 nextTag = tagReader.readTag();
163 }
164 return element;
165 }
166
167
168 private IqPacket processIq(Tag currentTag) throws XmlPullParserException, IOException {
169 IqPacket packet = (IqPacket) processPacket(currentTag,PACKET_IQ);
170 if (iqPacketCallbacks.containsKey(packet.getId())) {
171 iqPacketCallbacks.get(packet.getId()).onIqPacketReceived(account,packet);
172 iqPacketCallbacks.remove(packet.getId());
173 } else if (this.unregisteredIqListener != null) {
174 this.unregisteredIqListener.onIqPacketReceived(account,packet);
175 }
176 return packet;
177 }
178
179 private void processMessage(Tag currentTag) throws XmlPullParserException, IOException {
180 MessagePacket packet = (MessagePacket) processPacket(currentTag, PACKET_MESSAGE);
181 if (this.messageListener != null) {
182 this.messageListener.onMessagePacketReceived(account,packet);
183 }
184 }
185
186 private void processPresence(Tag currentTag) throws XmlPullParserException, IOException {
187 PresencePacket packet = (PresencePacket) processPacket(currentTag, PACKET_PRESENCE);
188 if (this.presenceListener != null) {
189 this.presenceListener.onPresencePacketReceived(account,packet);
190 }
191 }
192
193 private void sendStartTLS() throws XmlPullParserException, IOException {
194 Tag startTLS = Tag.empty("starttls");
195 startTLS.setAttribute("xmlns", "urn:ietf:params:xml:ns:xmpp-tls");
196 Log.d(LOGTAG,account.getJid()+": sending starttls");
197 tagWriter.writeTag(startTLS).flush();
198 }
199
200 private void switchOverToTls(Tag currentTag) throws XmlPullParserException,
201 IOException {
202 Tag nextTag = tagReader.readTag(); // should be proceed end tag
203 Log.d(LOGTAG,account.getJid()+": now switch to ssl");
204 SSLSocket sslSocket;
205 try {
206 sslSocket = (SSLSocket) ((SSLSocketFactory) SSLSocketFactory
207 .getDefault()).createSocket(socket, socket.getInetAddress()
208 .getHostAddress(), socket.getPort(), true);
209 tagReader.setInputStream(sslSocket.getInputStream());
210 Log.d(LOGTAG, "reset inputstream");
211 tagWriter.setOutputStream(sslSocket.getOutputStream());
212 Log.d(LOGTAG, "switch over seemed to work");
213 isTlsEncrypted = true;
214 sendStartStream();
215 processStream(tagReader.readTag());
216 } catch (IOException e) {
217 Log.d(LOGTAG, account.getJid()+": error on ssl '" + e.getMessage()+"'");
218 }
219 }
220
221 private void sendSaslAuth() throws IOException, XmlPullParserException {
222 String saslString = SASL.plain(account.getUsername(),
223 account.getPassword());
224 Element auth = new Element("auth");
225 auth.setAttribute("xmlns", "urn:ietf:params:xml:ns:xmpp-sasl");
226 auth.setAttribute("mechanism", "PLAIN");
227 auth.setContent(saslString);
228 Log.d(LOGTAG,account.getJid()+": sending sasl "+auth.toString());
229 tagWriter.writeElement(auth);
230 tagWriter.flush();
231 }
232
233 private void processStreamFeatures(Tag currentTag)
234 throws XmlPullParserException, IOException {
235 this.streamFeatures = tagReader.readElement(currentTag);
236 Log.d(LOGTAG,account.getJid()+": process stream features "+streamFeatures);
237 if (this.streamFeatures.hasChild("starttls")&&account.isOptionSet(Account.OPTION_USETLS)) {
238 sendStartTLS();
239 } else if (this.streamFeatures.hasChild("mechanisms")&&shouldAuthenticate) {
240 sendSaslAuth();
241 }
242 if (this.streamFeatures.hasChild("bind")&&shouldBind) {
243 sendBindRequest();
244 if (this.streamFeatures.hasChild("session")) {
245 IqPacket startSession = new IqPacket(IqPacket.TYPE_SET);
246 Element session = new Element("session");
247 session.setAttribute("xmlns","urn:ietf:params:xml:ns:xmpp-session");
248 session.setContent("");
249 startSession.addChild(session);
250 sendIqPacket(startSession, null);
251 tagWriter.writeElement(startSession);
252 tagWriter.flush();
253 }
254 Element presence = new Element("presence");
255
256 tagWriter.writeElement(presence);
257 tagWriter.flush();
258 }
259 }
260
261 private void sendBindRequest() throws IOException {
262 IqPacket iq = new IqPacket(IqPacket.TYPE_SET);
263 Element bind = new Element("bind");
264 bind.setAttribute("xmlns","urn:ietf:params:xml:ns:xmpp-bind");
265 iq.addChild(bind);
266 this.sendIqPacket(iq, new OnIqPacketReceived() {
267 @Override
268 public void onIqPacketReceived(Account account, IqPacket packet) {
269 resource = packet.findChild("bind").findChild("jid").getContent().split("/")[1];
270 Log.d(LOGTAG,account.getJid()+": new resource is "+resource);
271 }
272 });
273 }
274
275 private void processStreamError(Tag currentTag) {
276 Log.d(LOGTAG, "processStreamError");
277 }
278
279 private void sendStartStream() throws IOException {
280 Tag stream = Tag.start("stream");
281 stream.setAttribute("from", account.getJid());
282 stream.setAttribute("to", account.getServer());
283 stream.setAttribute("version", "1.0");
284 stream.setAttribute("xml:lang", "en");
285 stream.setAttribute("xmlns", "jabber:client");
286 stream.setAttribute("xmlns:stream", "http://etherx.jabber.org/streams");
287 tagWriter.writeTag(stream).flush();
288 }
289
290 private String nextRandomId() {
291 return new BigInteger(50, random).toString(32);
292 }
293
294 public void sendIqPacket(IqPacket packet, OnIqPacketReceived callback) throws IOException {
295 String id = nextRandomId();
296 packet.setAttribute("id",id);
297 tagWriter.writeElement(packet);
298 if (callback != null) {
299 iqPacketCallbacks.put(id, callback);
300 }
301 tagWriter.flush();
302 Log.d(LOGTAG,"sending: "+packet.toString());
303 }
304
305 public void sendMessagePacket(MessagePacket packet) throws IOException {
306 tagWriter.writeElement(packet);
307 tagWriter.flush();
308 }
309
310 public void sendPresencePacket(PresencePacket packet) throws IOException {
311 tagWriter.writeElement(packet);
312 tagWriter.flush();
313 }
314
315 public void setOnMessagePacketReceivedListener(OnMessagePacketReceived listener) {
316 this.messageListener = listener;
317 }
318
319 public void setOnUnregisteredIqPacketReceivedListener(OnIqPacketReceived listener) {
320 this.unregisteredIqListener = listener;
321 }
322
323 public void setOnPresencePacketReceivedListener(OnPresencePacketReceived listener) {
324 this.presenceListener = listener;
325 }
326}