Swiftdiff options
Diffstat (limited to 'src/com')
229 files changed, 12090 insertions, 0 deletions
diff --git a/src/com/isode/stroke/base/ByteArray.java b/src/com/isode/stroke/base/ByteArray.java new file mode 100644 index 0000000..a36e305 --- /dev/null +++ b/src/com/isode/stroke/base/ByteArray.java @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.base; + +import java.io.UnsupportedEncodingException; + +/** + * + */ +public class ByteArray { + + public ByteArray() { + } + + public ByteArray(String s) { + try { + fromBytes(s.getBytes("UTF-8")); + } catch (UnsupportedEncodingException ex) { + throw new IllegalStateException("JVM has no 'UTF-8' encoding"); + } + } + + public ByteArray(byte[] c) { + fromBytes(c); + } + + public ByteArray(ByteArray b) { + fromBytes(b.getData()); + } + + private void fromBytes(final byte[] b) { + data_ = new byte[b.length]; + System.arraycopy(b, 0, data_, 0, b.length); + } + + /*public ByteArray(char[] c, int n) { + for (int i = 0; i < n; i++) { + append(c[i]); + } + }*/ + + /** + * These are the raw, modifyable data! + * @return + */ + public byte[] getData() { + return data_; + } + + public int getSize() { + return data_.length; + } + + public boolean isEmpty() { + return getSize() == 0; + } + + /*public void resize(size_t size) { + return data_.resize(size); + }*/ + /** Immutable add */ + public static ByteArray plus(ByteArray a, ByteArray b) { + ByteArray x = new ByteArray(a.getData()); + x.append(b); + return x; + } + + /** Immutable add */ + /*public ByteArray plus(ByteArray a, char b) { + ByteArray x = new ByteArray(a.getData()); + x.append(b); + return x; + }*/ + + /** Mutable add */ + public ByteArray append(ByteArray b) { + append(b.getData()); + return this; + } + + /** Mutable add */ + private ByteArray append(byte[] b) { + int newLength = data_.length + b.length; + byte[] newData = new byte[newLength]; + for (int i = 0; i < data_.length; i++) { + newData[i] = data_[i]; + } + for (int i = 0; i < b.length; i++) { + newData[i + data_.length] = b[i]; + } + data_ = newData; + return this; + } + + /** Mutable add */ + public ByteArray append(byte b) { + byte[] bytes = {b}; + append(bytes); + return this; + } + + /** mutable add */ + public ByteArray append(String s) { + byte[] bytes; + try { + bytes = s.getBytes("UTF-8"); + } catch (UnsupportedEncodingException ex) { + throw new IllegalStateException("JVM has no 'UTF-8' encoding"); + } + append(bytes); + return this; + } + + @Override + public int hashCode() { + int hash = 3; + hash = 97 * hash + (this.data_ != null ? this.data_.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object other) { + return other instanceof ByteArray && toString().equals(other.toString()); + } + + /*public char charAt(int i) { + return data_.charAt(i); + }*/ + + /*public const_iterator begin() const { + return data_.begin(); + } + + public const_iterator end() const { + return data_.end(); + }*/ + @Override + public String toString() { + try { + return new String(data_, "UTF-8"); + } catch (UnsupportedEncodingException ex) { + throw new IllegalStateException("JVM has no 'UTF-8' encoding"); + } + } + + public void readFromFile(String file) { + //FIXME: port + } + + public void clear() { + data_ = new byte[]{}; + } + private byte[] data_ = {}; + +} diff --git a/src/com/isode/stroke/base/Error.java b/src/com/isode/stroke/base/Error.java new file mode 100644 index 0000000..60ccbeb --- /dev/null +++ b/src/com/isode/stroke/base/Error.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.base; + +public interface Error { + +} diff --git a/src/com/isode/stroke/client/ClientError.java b/src/com/isode/stroke/client/ClientError.java new file mode 100644 index 0000000..9412e9a --- /dev/null +++ b/src/com/isode/stroke/client/ClientError.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.client; + +/** + * + */ +public class ClientError { + + private final Type type_; + + enum Type { + + UnknownError, + DomainNameResolveError, + ConnectionError, + ConnectionReadError, + ConnectionWriteError, + XMLError, + AuthenticationFailedError, + CompressionFailedError, + ServerVerificationFailedError, + NoSupportedAuthMechanismsError, + UnexpectedElementError, + ResourceBindError, + SessionStartError, + TLSError, + ClientCertificateLoadError, + ClientCertificateError, + // Certificate verification errors + UnknownCertificateError, + CertificateExpiredError, + CertificateNotYetValidError, + CertificateSelfSignedError, + CertificateRejectedError, + CertificateUntrustedError, + InvalidCertificatePurposeError, + CertificatePathLengthExceededError, + InvalidCertificateSignatureError, + InvalidCAError, + InvalidServerIdentityError, + }; + + ClientError(Type type) { + type_ = type; + } + + Type getType() { + return type_; + } +} diff --git a/src/com/isode/stroke/client/ClientOptions.java b/src/com/isode/stroke/client/ClientOptions.java new file mode 100644 index 0000000..dad4204 --- /dev/null +++ b/src/com/isode/stroke/client/ClientOptions.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.client; + +/** + * + */ +public class ClientOptions { + + enum UseTLS { + + NeverUseTLS, + UseTLSWhenAvailable + }; + + public ClientOptions() { + useStreamCompression = true; + useTLS = UseTLS.UseTLSWhenAvailable; + useStreamResumption = false; + } + /** + * Whether ZLib stream compression should be used when available. + * + * Default: true + */ + public boolean useStreamCompression; + /** + * Sets whether TLS encryption should be used. + * + * Default: UseTLSWhenAvailable + */ + public UseTLS useTLS; + /** + * Use XEP-196 stream resumption when available. + * + * Default: false + */ + public boolean useStreamResumption; +} diff --git a/src/com/isode/stroke/client/ClientSession.java b/src/com/isode/stroke/client/ClientSession.java new file mode 100644 index 0000000..59427b0 --- /dev/null +++ b/src/com/isode/stroke/client/ClientSession.java @@ -0,0 +1,608 @@ +/* + * Copyright (c) 2010-2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010-2011 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.client; + +import com.isode.stroke.elements.AuthChallenge; +import com.isode.stroke.elements.AuthFailure; +import com.isode.stroke.elements.AuthRequest; +import com.isode.stroke.elements.AuthResponse; +import com.isode.stroke.elements.AuthSuccess; +import com.isode.stroke.elements.CompressFailure; +import com.isode.stroke.elements.CompressRequest; +import com.isode.stroke.elements.Compressed; +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.EnableStreamManagement; +import com.isode.stroke.elements.IQ; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.elements.ResourceBind; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.elements.StanzaAck; +import com.isode.stroke.elements.StanzaAckRequest; +import com.isode.stroke.elements.StartSession; +import com.isode.stroke.elements.StartTLSFailure; +import com.isode.stroke.elements.StreamFeatures; +import com.isode.stroke.elements.StartTLSRequest; +import com.isode.stroke.elements.StreamError; +import com.isode.stroke.elements.StreamManagementEnabled; +import com.isode.stroke.elements.StreamManagementFailed; +import com.isode.stroke.elements.TLSProceed; +import com.isode.stroke.jid.JID; +import com.isode.stroke.sasl.ClientAuthenticator; +import com.isode.stroke.sasl.PLAINClientAuthenticator; +import com.isode.stroke.sasl.SCRAMSHA1ClientAuthenticator; +import com.isode.stroke.session.SessionStream; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.signals.SignalConnection; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.streammanagement.StanzaAckRequester; +import com.isode.stroke.streammanagement.StanzaAckResponder; +import com.isode.stroke.tls.Certificate; +import com.isode.stroke.tls.CertificateTrustChecker; +import com.isode.stroke.tls.CertificateVerificationError; +import com.isode.stroke.tls.ServerIdentityVerifier; +import java.util.UUID; + +public class ClientSession { + private SignalConnection streamElementReceivedConnection; + private SignalConnection streamStreamStartReceivedConnection; + private SignalConnection streamClosedConnection; + private SignalConnection streamTLSEncryptedConnection; + private SignalConnection stanzaAckOnRequestConnection_; + private SignalConnection stanzaAckOnAckedConnection_; + private SignalConnection stanzaResponderAckConnection_; + + public enum State { + + Initial, + WaitingForStreamStart, + Negotiating, + Compressing, + WaitingForEncrypt, + Encrypting, + WaitingForCredentials, + Authenticating, + EnablingSessionManagement, + BindingResource, + StartingSession, + Initialized, + Finishing, + Finished + }; + + public static class Error implements com.isode.stroke.base.Error { + + public enum Type { + + AuthenticationFailedError, + CompressionFailedError, + ServerVerificationFailedError, + NoSupportedAuthMechanismsError, + UnexpectedElementError, + ResourceBindError, + SessionStartError, + TLSClientCertificateError, + TLSError, + StreamError + }; + + public Error(Type type) { + if (type == null) { + throw new IllegalStateException(); + } + this.type = type; + } + public final Type type; + }; + + public enum UseTLS { + NeverUseTLS, + UseTLSWhenAvailable + } + + private ClientSession(JID jid, SessionStream stream) { + localJID = jid; + state = State.Initial; + this.stream = stream; + allowPLAINOverNonTLS = true; /* FIXME: false */ + needSessionStart = false; + needResourceBind = false; + needAcking = false; + authenticator = null; + } + + public static ClientSession create(JID jid, SessionStream stream) { + return new ClientSession(jid, stream); + } + + public State getState() { + return state; + } + + public void setAllowPLAINOverNonTLS(boolean b) { + allowPLAINOverNonTLS = b; + } + + public void setUseStreamCompression(boolean b) { + useStreamCompression = b; + } + + public void setUseTLS(UseTLS use) { + useTLS = use; + } + + public boolean getStreamManagementEnabled() { + return stanzaAckRequester_ != null; + } + + public boolean getRosterVersioningSuported() { + return rosterVersioningSupported; + } + + public JID getLocalJID() { + return localJID; + } + + public boolean isFinished() { + return State.Finished.equals(getState()); + } + + public void setCertificateTrustChecker(CertificateTrustChecker checker) { + certificateTrustChecker = checker; + } + + public void start() { + streamStreamStartReceivedConnection = stream.onStreamStartReceived.connect(new Slot1<ProtocolHeader>(){ + public void call(ProtocolHeader p1) { + handleStreamStart(p1); + } + }); + streamElementReceivedConnection = stream.onElementReceived.connect(new Slot1<Element>(){ + public void call(Element p1) { + handleElement(p1); + } + }); + streamClosedConnection = stream.onClosed.connect(new Slot1<SessionStream.Error>(){ + public void call(SessionStream.Error p1) { + handleStreamClosed(p1); + } + }); + streamTLSEncryptedConnection = stream.onTLSEncrypted.connect(new Slot(){ + public void call() { + handleTLSEncrypted(); + } + }); + + assert state.equals(State.Initial); + state = State.WaitingForStreamStart; + sendStreamHeader(); + } + + private void sendStreamHeader() { + ProtocolHeader header = new ProtocolHeader(); + header.setTo(getRemoteJID().toString()); + stream.writeHeader(header); + } + + public void sendStanza(Stanza stanza) { + stream.writeElement(stanza); + if (stanzaAckRequester_ != null) { + stanzaAckRequester_.handleStanzaSent(stanza); + } + } + + private void handleStreamStart(ProtocolHeader header) { + if (!checkState(State.WaitingForStreamStart)) { + return; + } + state = State.Negotiating; + } + + private void handleElement(Element element) { + if (element instanceof Stanza) { + Stanza stanza = (Stanza) element; + if (stanzaAckResponder_ != null) { + stanzaAckResponder_.handleStanzaReceived(); + } + if (getState().equals(State.Initialized)) { + onStanzaReceived.emit(stanza); + } + else if (stanza instanceof IQ) { + IQ iq = (IQ)stanza; + if (getState().equals(State.BindingResource)) { + ResourceBind resourceBind = iq.getPayload(new ResourceBind()); + if (IQ.Type.Error.equals(iq.getType()) && iq.getID().equals("session-bind")) { + finishSession(Error.Type.ResourceBindError); + } + else if (resourceBind == null) { + finishSession(Error.Type.UnexpectedElementError); + } + else if (IQ.Type.Result.equals(iq.getType())) { + localJID = resourceBind.getJID(); + if (!localJID.isValid()) { + finishSession(Error.Type.ResourceBindError); + } + needResourceBind = false; + continueSessionInitialization(); + } + else { + finishSession(Error.Type.UnexpectedElementError); + } + } + else if (state.equals(State.StartingSession)) { + if (IQ.Type.Result.equals(iq.getType())) { + needSessionStart = false; + continueSessionInitialization(); + } + else if (IQ.Type.Error.equals(iq.getType())) { + finishSession(Error.Type.SessionStartError); + } + else { + finishSession(Error.Type.UnexpectedElementError); + } + } + else { + finishSession(Error.Type.UnexpectedElementError); + } + } + } + else if (element instanceof StanzaAckRequest) { + if (stanzaAckResponder_ != null) { + + stanzaAckResponder_.handleAckRequestReceived(); + } + } + else if (element instanceof StanzaAck) { + StanzaAck ack = (StanzaAck) element; + if (stanzaAckRequester_ != null) { + if (ack.isValid()) { + stanzaAckRequester_.handleAckReceived(ack.getHandledStanzasCount()); + } + else { + //logger_.warning("Got invalid ack from server"); /*FIXME: Do we want logging here? + } + } + else { + //logger_.warning("Ignoring ack"); /*FIXME: Do we want logging here?*/ + } + } + else if (element instanceof StreamError) { + finishSession(Error.Type.StreamError); + } + else if (State.Initialized.equals(getState())) { + Stanza stanza = element instanceof Stanza ? (Stanza)element : null; + if (stanza != null) { + if (stanzaAckResponder_ != null) { + stanzaAckResponder_.handleStanzaReceived(); + } + onStanzaReceived.emit(stanza); + } + } + else if (element instanceof StreamFeatures) { + StreamFeatures streamFeatures = (StreamFeatures) element; + if (!checkState(State.Negotiating)) { + return; + } + + if (streamFeatures.hasStartTLS() && stream.supportsTLSEncryption()) { + state = State.WaitingForEncrypt; + stream.writeElement(new StartTLSRequest()); + } + else if (false && streamFeatures.hasCompressionMethod("zlib")) { /*FIXME: test and enable!*/ + state = State.Compressing; + stream.writeElement(new CompressRequest("zlib")); + } + else if (streamFeatures.hasAuthenticationMechanisms()) { + if (stream.hasTLSCertificate()) { + if (streamFeatures.hasAuthenticationMechanism("EXTERNAL")) { + state = State.Authenticating; + stream.writeElement(new AuthRequest("EXTERNAL")); + } + else { + finishSession(Error.Type.TLSClientCertificateError); + } + } + else if (streamFeatures.hasAuthenticationMechanism("EXTERNAL")) { + state = State.Authenticating; + stream.writeElement(new AuthRequest("EXTERNAL")); + } + else if (streamFeatures.hasAuthenticationMechanism("SCRAM-SHA-1") || streamFeatures.hasAuthenticationMechanism("SCRAM-SHA-1-PLUS")) { + SCRAMSHA1ClientAuthenticator scramAuthenticator = new SCRAMSHA1ClientAuthenticator(UUID.randomUUID().toString(), streamFeatures.hasAuthenticationMechanism("SCRAM-SHA-1-PLUS")); + if (stream.isTLSEncrypted()) { + scramAuthenticator.setTLSChannelBindingData(stream.getTLSFinishMessage()); + } + authenticator = scramAuthenticator; + state = State.WaitingForCredentials; + onNeedCredentials.emit(); + } + else if ((stream.isTLSEncrypted() || allowPLAINOverNonTLS) && streamFeatures.hasAuthenticationMechanism("PLAIN")) { + authenticator = new PLAINClientAuthenticator(); + state = State.WaitingForCredentials; + onNeedCredentials.emit(); + } +// //FIXME: Port +// else if (streamFeatures.hasAuthenticationMechanism("DIGEST-MD5")) { +// // FIXME: Host should probably be the actual host +// authenticator = new DIGESTMD5ClientAuthenticator(localJID.getDomain(), UUID.randomUUID()); +// state = State.WaitingForCredentials; +// onNeedCredentials.emit(); +// } + else { + finishSession(Error.Type.NoSupportedAuthMechanismsError); + } + } + else { + // Start the session + rosterVersioningSupported = streamFeatures.hasRosterVersioning(); + stream.setWhitespacePingEnabled(true); + needSessionStart = streamFeatures.hasSession(); + needResourceBind = streamFeatures.hasResourceBind(); + needAcking = streamFeatures.hasStreamManagement(); + if (!needResourceBind) { + // Resource binding is a MUST + finishSession(Error.Type.ResourceBindError); + } else { + continueSessionInitialization(); + } + } + } + else if (element instanceof Compressed) { + checkState(State.Compressing); + state = State.WaitingForStreamStart; + stream.addZLibCompression(); + stream.resetXMPPParser(); + sendStreamHeader(); + } + else if (element instanceof CompressFailure) { + finishSession(Error.Type.CompressionFailedError); + } + else if (element instanceof StreamManagementEnabled) { + stanzaAckRequester_ = new StanzaAckRequester(); + stanzaAckOnRequestConnection_ = stanzaAckRequester_.onRequestAck.connect(new Slot() { + + public void call() { + requestAck(); + } + }); + stanzaAckOnAckedConnection_ = stanzaAckRequester_.onStanzaAcked.connect(new Slot1<Stanza>() { + + public void call(Stanza p1) { + handleStanzaAcked(p1); + } + }); + stanzaAckResponder_ = new StanzaAckResponder(); + stanzaResponderAckConnection_ = stanzaAckResponder_.onAck.connect(new Slot1<Long>() { + + public void call(Long p1) { + ack(p1); + } + }); + needAcking = false; + continueSessionInitialization(); + } + else if (element instanceof StreamManagementFailed) { + needAcking = false; + continueSessionInitialization(); + } + else if (element instanceof AuthChallenge) { + AuthChallenge challenge = (AuthChallenge) element; + checkState(State.Authenticating); + assert authenticator != null; + if (authenticator.setChallenge(challenge.getValue())) { + stream.writeElement(new AuthResponse(authenticator.getResponse())); + } + else { + finishSession(Error.Type.AuthenticationFailedError); + } + } + else if (element instanceof AuthSuccess) { + AuthSuccess authSuccess = (AuthSuccess)element; + checkState(State.Authenticating); + if (authenticator != null && !authenticator.setChallenge(authSuccess.getValue())) { + finishSession(Error.Type.ServerVerificationFailedError); + } + else { + state = State.WaitingForStreamStart; + authenticator = null; + stream.resetXMPPParser(); + sendStreamHeader(); + } + } + else if (element instanceof AuthFailure) { + authenticator = null; + finishSession(Error.Type.AuthenticationFailedError); + } + else if (element instanceof TLSProceed) { + if (!checkState(State.WaitingForEncrypt)) { + return; + } + state = State.Encrypting; + stream.addTLSEncryption(); + } + else if (element instanceof StartTLSFailure) { + finishSession(Error.Type.TLSError); + } + else { + // FIXME Not correct? + state = State.Initialized; + onInitialized.emit(); + } + } + + private void continueSessionInitialization() { + if (needResourceBind) { + state = State.BindingResource; + ResourceBind resourceBind = new ResourceBind(); + if (localJID.getResource().length() != 0) { + resourceBind.setResource(localJID.getResource()); + } + sendStanza(IQ.createRequest(IQ.Type.Set, new JID(), "session-bind", resourceBind)); + } + else if (needAcking) { + state = State.EnablingSessionManagement; + stream.writeElement(new EnableStreamManagement()); + } + else if (needSessionStart) { + state = State.StartingSession; + sendStanza(IQ.createRequest(IQ.Type.Set, new JID(), "session-start", new StartSession())); + } + else { + state = State.Initialized; + onInitialized.emit(); + } + } + + private boolean checkState(State state) { + State currentState = this.state; /* For symbol debugging, as the following overwrites it */ + if (!currentState.equals(state)) { + finishSession(Error.Type.UnexpectedElementError); + return false; + } + return true; + } + + public void sendCredentials(String password) { + if (!checkState(State.WaitingForCredentials)) { + throw new IllegalStateException("Asking for credentials when we shouldn't be asked."); + } + state = State.Authenticating; + authenticator.setCredentials(localJID.getNode(), password); + stream.writeElement(new AuthRequest(authenticator.getName(), authenticator.getResponse())); + } + + private void handleTLSEncrypted() { + if (!checkState(State.Encrypting)) { + return; + } + Certificate certificate = stream.getPeerCertificate(); + CertificateVerificationError verificationError = stream.getPeerCertificateVerificationError(); + if (verificationError != null) { + checkTrustOrFinish(certificate, verificationError); + } + else { + ServerIdentityVerifier identityVerifier = new ServerIdentityVerifier(localJID); + if (identityVerifier.certificateVerifies(certificate)) { + continueAfterTLSEncrypted(); + } + else { + checkTrustOrFinish(certificate, new CertificateVerificationError(CertificateVerificationError.Type.InvalidServerIdentity)); + } + } + } + + private void checkTrustOrFinish(Certificate certificate, CertificateVerificationError error) { + if (certificateTrustChecker != null && certificateTrustChecker.isCertificateTrusted(certificate)) { + continueAfterTLSEncrypted(); + } + else { + finishSession(error); + } + } + + private void continueAfterTLSEncrypted() { + state = State.WaitingForStreamStart; + stream.resetXMPPParser(); + sendStreamHeader(); + } + + private void handleStreamClosed(SessionStream.Error streamError) { + State previousState = state; + state = State.Finished; + + if (stanzaAckRequester_ != null) { + stanzaAckOnRequestConnection_.disconnect(); + stanzaAckOnAckedConnection_.disconnect(); + stanzaAckRequester_ = null; + } + if (stanzaAckResponder_ != null) { + stanzaResponderAckConnection_.disconnect(); + stanzaAckResponder_ = null; + } + stream.setWhitespacePingEnabled(false); + streamStreamStartReceivedConnection.disconnect(); + streamElementReceivedConnection.disconnect(); + streamClosedConnection.disconnect(); + streamTLSEncryptedConnection.disconnect(); + + if (State.Finishing.equals(previousState)) { + onFinished.emit(error_); + } + else { + onFinished.emit(streamError); + } + } + + public void finish() { + finishSession((Error.Type)null); + } + + private void finishSession(Error.Type error) { + Error localError = null; + if (error != null) { + localError = new Error(error); + } + finishSession(localError); + } + + private void finishSession(com.isode.stroke.base.Error error) { + state = State.Finishing; + error_ = error; + assert(stream.isOpen()); + if (stanzaAckResponder_ != null) { + stanzaAckResponder_.handleAckRequestReceived(); + } + stream.writeFooter(); + stream.close(); + } + + private void requestAck() { + stream.writeElement(new StanzaAckRequest()); + } + + private void handleStanzaAcked(Stanza stanza) { + onStanzaAcked.emit(stanza); + } + + private void ack(long handledStanzasCount) { + stream.writeElement(new StanzaAck(handledStanzasCount)); + } + + public final Signal onNeedCredentials = new Signal(); + public final Signal onInitialized = new Signal(); + public final Signal1<com.isode.stroke.base.Error> onFinished = new Signal1<com.isode.stroke.base.Error>(); + public final Signal1<Stanza> onStanzaReceived = new Signal1<Stanza>(); + public final Signal1<Stanza> onStanzaAcked = new Signal1<Stanza>(); + + + + + + + + private JID getRemoteJID() { + return new JID("", localJID.getDomain()); + } + + private JID localJID; + private State state; + private SessionStream stream; + private boolean allowPLAINOverNonTLS; + private boolean useStreamCompression; + private UseTLS useTLS; + private boolean needSessionStart; + private boolean needResourceBind; + private boolean needAcking; + private boolean rosterVersioningSupported; + private ClientAuthenticator authenticator; + private StanzaAckRequester stanzaAckRequester_; + private StanzaAckResponder stanzaAckResponder_; + private com.isode.stroke.base.Error error_; + private CertificateTrustChecker certificateTrustChecker; +} diff --git a/src/com/isode/stroke/client/ClientSessionStanzaChannel.java b/src/com/isode/stroke/client/ClientSessionStanzaChannel.java new file mode 100644 index 0000000..531ff62 --- /dev/null +++ b/src/com/isode/stroke/client/ClientSessionStanzaChannel.java @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.client; + +import com.isode.stroke.base.Error; +import com.isode.stroke.elements.IQ; +import com.isode.stroke.elements.Message; +import com.isode.stroke.elements.Presence; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.signals.SignalConnection; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import java.util.logging.Logger; + +/** + * StanzaChannel implementation around a ClientSession. + */ +public class ClientSessionStanzaChannel extends StanzaChannel { + private SignalConnection sessionInitializedConnection; + private SignalConnection sessionFinishedConnection; + private SignalConnection sessionStanzaReceivedConnection; + private SignalConnection sessionStanzaAckedConnection; + + public void setSession(ClientSession session) { + assert this.session == null; + this.session = session; + sessionInitializedConnection = session.onInitialized.connect(new Slot() { + + public void call() { + handleSessionInitialized(); + } + }); + sessionFinishedConnection = session.onFinished.connect(new Slot1<com.isode.stroke.base.Error>() { + + public void call(com.isode.stroke.base.Error p1) { + handleSessionFinished(p1); + } + }); + sessionStanzaReceivedConnection = session.onStanzaReceived.connect(new Slot1<Stanza>() { + + public void call(Stanza p1) { + handleStanza(p1); + } + }); + sessionStanzaAckedConnection = session.onStanzaAcked.connect(new Slot1<Stanza>() { + + public void call(Stanza p1) { + handleStanzaAcked(p1); + } + }); + } + + public void sendIQ(IQ iq) { + send(iq); + } + + public void sendMessage(Message message) { + send(message); + } + + public void sendPresence(Presence presence) { + send(presence); + } + + public boolean getStreamManagementEnabled() { + if (session != null) { + return session.getStreamManagementEnabled(); + } + return false; + } + + public boolean isAvailable() { + return session != null && ClientSession.State.Initialized.equals(session.getState()); + } + + public String getNewIQID() { + return idGenerator.generateID(); + } + + private void send(Stanza stanza) { + if (!isAvailable()) { + logger_.warning("Warning: Client: Trying to send a stanza while disconnected."); + return; + } + session.sendStanza(stanza); + } + + private void handleSessionFinished(Error error) { + sessionFinishedConnection.disconnect(); + sessionStanzaReceivedConnection.disconnect(); + sessionStanzaAckedConnection.disconnect(); + sessionInitializedConnection.disconnect(); + session = null; + onAvailableChanged.emit(false); + } + + private void handleStanza(Stanza stanza) { + if (stanza instanceof Message) { + onMessageReceived.emit((Message)stanza); + } + if (stanza instanceof Presence) { + onPresenceReceived.emit((Presence)stanza); + } + if (stanza instanceof IQ) { + onIQReceived.emit((IQ)stanza); + } + } + + private void handleStanzaAcked(Stanza stanza) { + onStanzaAcked.emit(stanza); + } + + private void handleSessionInitialized() { + onAvailableChanged.emit(true); + } + private IDGenerator idGenerator = new IDGenerator(); + private ClientSession session; + private static final Logger logger_ = Logger.getLogger(ClientSessionStanzaChannel.class.getName()); +} diff --git a/src/com/isode/stroke/client/CoreClient.java b/src/com/isode/stroke/client/CoreClient.java new file mode 100644 index 0000000..0ce1503 --- /dev/null +++ b/src/com/isode/stroke/client/CoreClient.java @@ -0,0 +1,385 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.client; + +import com.isode.stroke.elements.Message; +import com.isode.stroke.elements.Presence; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.elements.StreamType; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.jid.JID; +import com.isode.stroke.network.Connection; +import com.isode.stroke.network.ConnectionFactory; +import com.isode.stroke.network.Connector; +import com.isode.stroke.network.NetworkFactories; +import com.isode.stroke.network.PlatformDomainNameResolver; +import com.isode.stroke.network.TimerFactory; +import com.isode.stroke.parser.payloadparsers.FullPayloadParserFactoryCollection; +import com.isode.stroke.queries.IQRouter; +import com.isode.stroke.serializer.payloadserializers.FullPayloadSerializerCollection; +import com.isode.stroke.session.BasicSessionStream; +import com.isode.stroke.session.SessionStream; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.signals.SignalConnection; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.tls.CertificateTrustChecker; +import com.isode.stroke.tls.CertificateVerificationError; +import com.isode.stroke.tls.PKCS12Certificate; +import com.isode.stroke.tls.PlatformTLSFactories; +import com.isode.stroke.tls.TLSContextFactory; + +/** + * The central class for communicating with an XMPP server. + * + * This class is responsible for setting up the connection with the XMPP server, authenticating, and + * initializing the session. + * + * This class can be used directly in your application, although the Client subclass provides more + * functionality and interfaces, and is better suited for most needs. + */ +public class CoreClient { + private SignalConnection sessionStreamDataReadConnection_; + private SignalConnection sessionStreamDataWrittenConnection_; + private SignalConnection sessionFinishedConnection_; + private SignalConnection sessionNeedCredentialsConnection_; + private SignalConnection connectorConnectFinishedConnection_; + private final EventLoop eventLoop_; + + public CoreClient(EventLoop eventLoop, JID jid, String password, NetworkFactories networkFactories) { + jid_ = jid; + password_ = password; + disconnectRequested_ = false; + eventLoop_ = eventLoop; + this.networkFactories = networkFactories; + this.certificateTrustChecker = null; + resolver_ = new PlatformDomainNameResolver(eventLoop); + stanzaChannel_ = new ClientSessionStanzaChannel(); + stanzaChannel_.onMessageReceived.connect(new Slot1<Message>() { + + public void call(Message p1) { + onMessageReceived.emit(p1); + } + }); + stanzaChannel_.onPresenceReceived.connect(new Slot1<Presence>() { + + public void call(Presence p1) { + onPresenceReceived.emit(p1); + } + }); + stanzaChannel_.onStanzaAcked.connect(new Slot1<Stanza>() { + + public void call(Stanza p1) { + onStanzaAcked.emit(p1); + } + }); + stanzaChannel_.onAvailableChanged.connect(new Slot1<Boolean>() { + + public void call(Boolean p1) { + handleStanzaChannelAvailableChanged(p1); + } + }); + + iqRouter_ = new IQRouter(stanzaChannel_); + tlsFactories = new PlatformTLSFactories(); + } + + /*CoreClient::~CoreClient() { + if (session_ || connection_) { + std::cerr << "Warning: Client not disconnected properly" << std::endl; + } + delete tlsLayerFactory_; + delete timerFactory_; + delete connectionFactory_; + delete iqRouter_; + + stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1)); + stanzaChannel_->onMessageReceived.disconnect(boost::ref(onMessageReceived)); + stanzaChannel_->onPresenceReceived.disconnect(boost::ref(onPresenceReceived)); + stanzaChannel_->onStanzaAcked.disconnect(boost::ref(onStanzaAcked)); + delete stanzaChannel_; + }*/ + public void connect(ClientOptions o) { + options = o; + connect(jid_.getDomain()); + } + + public void connect(String host) { + disconnectRequested_ = false; + assert (connector_ == null); + /* FIXME: Port Proxies */ + connector_ = Connector.create(host, networkFactories.getDomainNameResolver(), networkFactories.getConnectionFactory(), networkFactories.getTimerFactory()); + connectorConnectFinishedConnection_ = connector_.onConnectFinished.connect(new Slot1<Connection>() { + public void call(Connection p1) { + handleConnectorFinished(p1); + } + }); + connector_.setTimeoutMilliseconds(60 * 1000); + connector_.start(); + } + + void handleConnectorFinished(Connection connection) { + if (connectorConnectFinishedConnection_ != null) { + connectorConnectFinishedConnection_.disconnect(); + } + connector_ = null; + if (connection == null) { + if (!disconnectRequested_) { + onError.emit(new ClientError(ClientError.Type.ConnectionError)); + } + } else { + assert (connection_ == null); + connection_ = connection; + + assert (sessionStream_ == null); + sessionStream_ = new BasicSessionStream(StreamType.ClientStreamType, connection_, payloadParserFactories_, payloadSerializers_, tlsFactories.getTLSContextFactory(), networkFactories.getTimerFactory(), eventLoop_); + if (certificate_ != null && !certificate_.isEmpty()) { + sessionStream_.setTLSCertificate(new PKCS12Certificate(certificate_, password_)); + } + sessionStreamDataReadConnection_ = sessionStream_.onDataRead.connect(new Slot1<String>() { + + public void call(String p1) { + handleDataRead(p1); + } + }); + + sessionStreamDataWrittenConnection_ = sessionStream_.onDataWritten.connect(new Slot1<String>() { + + public void call(String p1) { + handleDataWritten(p1); + } + }); + + session_ = ClientSession.create(jid_, sessionStream_); + session_.setCertificateTrustChecker(certificateTrustChecker); + session_.setUseStreamCompression(options.useStreamCompression); + switch (options.useTLS) { + case UseTLSWhenAvailable: + session_.setUseTLS(ClientSession.UseTLS.UseTLSWhenAvailable); + break; + case NeverUseTLS: + session_.setUseTLS(ClientSession.UseTLS.NeverUseTLS); + break; + } + stanzaChannel_.setSession(session_); + sessionFinishedConnection_ = session_.onFinished.connect(new Slot1<com.isode.stroke.base.Error>() { + + public void call(com.isode.stroke.base.Error p1) { + handleSessionFinished(p1); + } + }); + sessionNeedCredentialsConnection_ = session_.onNeedCredentials.connect(new Slot() { + + public void call() { + handleNeedCredentials(); + } + }); + session_.start(); + } + } + + public void disconnect() { + // FIXME: We should be able to do without this boolean. We just have to make sure we can tell the difference between + // connector finishing without a connection due to an error or because of a disconnect. + disconnectRequested_ = true; + if (session_ != null && !session_.isFinished()) { + session_.finish(); + } else if (connector_ != null) { + connector_.stop(); + } + } + + public void setCertificate(String certificate) { + certificate_ = certificate; + } + + private void handleSessionFinished(com.isode.stroke.base.Error error) { + sessionFinishedConnection_.disconnect(); + sessionNeedCredentialsConnection_.disconnect(); + session_ = null; + + sessionStreamDataReadConnection_.disconnect(); + sessionStreamDataWrittenConnection_.disconnect(); + sessionStream_ = null; + + connection_.disconnect(); + connection_ = null; + + if (error != null) { + ClientError clientError = null; + if (error instanceof ClientSession.Error) { + ClientSession.Error actualError = (ClientSession.Error) error; + switch (actualError.type) { + case AuthenticationFailedError: + clientError = new ClientError(ClientError.Type.AuthenticationFailedError); + break; + case CompressionFailedError: + clientError = new ClientError(ClientError.Type.CompressionFailedError); + break; + case ServerVerificationFailedError: + clientError = new ClientError(ClientError.Type.ServerVerificationFailedError); + break; + case NoSupportedAuthMechanismsError: + clientError = new ClientError(ClientError.Type.NoSupportedAuthMechanismsError); + break; + case UnexpectedElementError: + clientError = new ClientError(ClientError.Type.UnexpectedElementError); + break; + case ResourceBindError: + clientError = new ClientError(ClientError.Type.ResourceBindError); + break; + case SessionStartError: + clientError = new ClientError(ClientError.Type.SessionStartError); + break; + case TLSError: + clientError = new ClientError(ClientError.Type.TLSError); + break; + case TLSClientCertificateError: + clientError = new ClientError(ClientError.Type.ClientCertificateError); + break; + } + } else if (error instanceof SessionStream.Error) { + SessionStream.Error actualError = (SessionStream.Error) error; + switch (actualError.type) { + case ParseError: + clientError = new ClientError(ClientError.Type.XMLError); + break; + case TLSError: + clientError = new ClientError(ClientError.Type.TLSError); + break; + case InvalidTLSCertificateError: + clientError = new ClientError(ClientError.Type.ClientCertificateLoadError); + break; + case ConnectionReadError: + clientError = new ClientError(ClientError.Type.ConnectionReadError); + break; + case ConnectionWriteError: + clientError = new ClientError(ClientError.Type.ConnectionWriteError); + break; + } + } else if (error instanceof CertificateVerificationError) { + CertificateVerificationError verificationError = (CertificateVerificationError)error; + switch (verificationError.type) { + case UnknownError: + clientError = new ClientError(ClientError.Type.UnknownCertificateError); + break; + case Expired: + clientError = new ClientError(ClientError.Type.CertificateExpiredError); + break; + case NotYetValid: + clientError = new ClientError(ClientError.Type.CertificateNotYetValidError); + break; + case SelfSigned: + clientError = new ClientError(ClientError.Type.CertificateSelfSignedError); + break; + case Rejected: + clientError = new ClientError(ClientError.Type.CertificateRejectedError); + break; + case Untrusted: + clientError = new ClientError(ClientError.Type.CertificateUntrustedError); + break; + case InvalidPurpose: + clientError = new ClientError(ClientError.Type.InvalidCertificatePurposeError); + break; + case PathLengthExceeded: + clientError = new ClientError(ClientError.Type.CertificatePathLengthExceededError); + break; + case InvalidSignature: + clientError = new ClientError(ClientError.Type.InvalidCertificateSignatureError); + break; + case InvalidCA: + clientError = new ClientError(ClientError.Type.InvalidCAError); + break; + case InvalidServerIdentity: + clientError = new ClientError(ClientError.Type.InvalidServerIdentityError); + break; + } + } + assert clientError != null; + onError.emit(clientError); + } + } + + private void handleNeedCredentials() { + assert session_ != null; + session_.sendCredentials(password_); + } + + private void handleDataRead(String data) { + onDataRead.emit(data); + } + + private void handleDataWritten(String data) { + onDataWritten.emit(data); + } + + private void handleStanzaChannelAvailableChanged(boolean available) { + if (available) { + onConnected.emit(); + } + } + + public void sendMessage(Message message) { + stanzaChannel_.sendMessage(message); + } + + public void sendPresence(Presence presence) { + stanzaChannel_.sendPresence(presence); + } + + public IQRouter getIQRouter() { + return iqRouter_; + } + + public StanzaChannel getStanzaChannel() { + return stanzaChannel_; + } + + public boolean isAvailable() { + return stanzaChannel_.isAvailable(); + } + + /** + * Returns the JID of the client. + * After the session was initialized, this returns the bound JID. + */ + public JID getJID() { + if (session_ != null) { + return session_.getLocalJID(); + } else { + return jid_; + } + } + public final Signal1<ClientError> onError = new Signal1<ClientError>(); + public final Signal onConnected = new Signal(); + public final Signal1<String> onDataRead = new Signal1<String>(); + public final Signal1<String> onDataWritten = new Signal1<String>(); + public final Signal1<Message> onMessageReceived = new Signal1<Message>(); + public final Signal1<Presence> onPresenceReceived = new Signal1<Presence>(); + public final Signal1<Stanza> onStanzaAcked = new Signal1<Stanza>(); + private PlatformDomainNameResolver resolver_; + private JID jid_; + private String password_; + private ClientSessionStanzaChannel stanzaChannel_; + private IQRouter iqRouter_; + private Connector connector_; + private ConnectionFactory connectionFactory_; + private FullPayloadParserFactoryCollection payloadParserFactories_ = new FullPayloadParserFactoryCollection(); + private FullPayloadSerializerCollection payloadSerializers_ = new FullPayloadSerializerCollection(); + private Connection connection_; + private BasicSessionStream sessionStream_; + private ClientSession session_; + private String certificate_; + private boolean disconnectRequested_; + private ClientOptions options; + private CertificateTrustChecker certificateTrustChecker; + private NetworkFactories networkFactories; + private PlatformTLSFactories tlsFactories; +} diff --git a/src/com/isode/stroke/client/IDGenerator.java b/src/com/isode/stroke/client/IDGenerator.java new file mode 100644 index 0000000..1810cdf --- /dev/null +++ b/src/com/isode/stroke/client/IDGenerator.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.client; + +/** + * + */ +public class IDGenerator { + private int next_ = 42; + public String generateID() { + next_++; + return String.valueOf(next_); + + } +} diff --git a/src/com/isode/stroke/client/StanzaChannel.java b/src/com/isode/stroke/client/StanzaChannel.java new file mode 100644 index 0000000..62984b5 --- /dev/null +++ b/src/com/isode/stroke/client/StanzaChannel.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ + +package com.isode.stroke.client; + +import com.isode.stroke.elements.Message; +import com.isode.stroke.elements.Presence; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.queries.IQChannel; +import com.isode.stroke.signals.Signal1; + +public abstract class StanzaChannel extends IQChannel { + + + public abstract void sendMessage(Message message); + + public abstract void sendPresence(Presence presence); + + public abstract boolean isAvailable(); + + public abstract boolean getStreamManagementEnabled(); + + public final Signal1<Message> onMessageReceived = new Signal1<Message>(); + public final Signal1<Presence> onPresenceReceived = new Signal1<Presence>(); + public final Signal1<Boolean> onAvailableChanged = new Signal1<Boolean>(); + public final Signal1<Stanza> onStanzaAcked = new Signal1<Stanza>(); + + +} diff --git a/src/com/isode/stroke/compress/ZLibCompressor.java b/src/com/isode/stroke/compress/ZLibCompressor.java new file mode 100644 index 0000000..f5276c8 --- /dev/null +++ b/src/com/isode/stroke/compress/ZLibCompressor.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.compress; + +import com.isode.stroke.base.ByteArray; +import java.util.zip.Deflater; + +/** + * + * @author Kev + */ +public class ZLibCompressor { + + private static final int COMPRESSION_LEVEL = 9; + + public ByteArray process(ByteArray data) throws ZLibException { + Deflater compressor = new Deflater(COMPRESSION_LEVEL); + compressor.setStrategy(Deflater.DEFAULT_STRATEGY); + compressor.setInput(data.getData()); + compressor.finish(); + byte[] output = new byte[100]; + ByteArray result = new ByteArray(); + while (!compressor.finished()) { + int size = compressor.deflate(output); + for (int i = 0; i < size; i++) { + result.append(output[i]); /* TODO: Terribly slow */ + } + } + return result; + } +} diff --git a/src/com/isode/stroke/compress/ZLibDecompressor.java b/src/com/isode/stroke/compress/ZLibDecompressor.java new file mode 100644 index 0000000..2c78a57 --- /dev/null +++ b/src/com/isode/stroke/compress/ZLibDecompressor.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.compress; + +import com.isode.stroke.base.ByteArray; +import java.util.zip.DataFormatException; +import java.util.zip.Inflater; + +/** + * + * @author Kev + */ +public class ZLibDecompressor { + Inflater inflater_ = new Inflater(); + public ByteArray process(ByteArray data) throws ZLibException { + try { + inflater_.setInput(data.getData()); + byte[] output = new byte[100]; + ByteArray result = new ByteArray(); + int size = 0; + while ((size = inflater_.inflate(output)) != 0) { + for (int i = 0; i < size; i++) { + result.append(output[i]); /* TODO: Terribly slow */ + } + } + return result; + } + catch (DataFormatException e) { + throw new ZLibException(); + } + } + +} diff --git a/src/com/isode/stroke/compress/ZLibException.java b/src/com/isode/stroke/compress/ZLibException.java new file mode 100644 index 0000000..48a2d31 --- /dev/null +++ b/src/com/isode/stroke/compress/ZLibException.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.compress; + +/** + * + * @author Kev + */ +public class ZLibException extends Exception { + +} diff --git a/src/com/isode/stroke/elements/AuthChallenge.java b/src/com/isode/stroke/elements/AuthChallenge.java new file mode 100644 index 0000000..ac87a3d --- /dev/null +++ b/src/com/isode/stroke/elements/AuthChallenge.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.base.ByteArray; + +public class AuthChallenge implements Element { + //FIXME: parser/serialiser + public AuthChallenge() { + value_ = new ByteArray(); + } + + public AuthChallenge(ByteArray value) { + value_ = new ByteArray(value); + } + + public ByteArray getValue() { + return value_; + } + + public void setValue(ByteArray value) { + value_ = new ByteArray(value); + } + + private ByteArray value_; +} diff --git a/src/com/isode/stroke/elements/AuthFailure.java b/src/com/isode/stroke/elements/AuthFailure.java new file mode 100644 index 0000000..ecd7639 --- /dev/null +++ b/src/com/isode/stroke/elements/AuthFailure.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + + +public class AuthFailure implements Element { + //FIXME: parser/serialiser +} diff --git a/src/com/isode/stroke/elements/AuthRequest.java b/src/com/isode/stroke/elements/AuthRequest.java new file mode 100644 index 0000000..21b1356 --- /dev/null +++ b/src/com/isode/stroke/elements/AuthRequest.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.base.ByteArray; + +public class AuthRequest implements Element { + + public AuthRequest() { + this(null); + } + + //FIXME: parser/serialiser + public AuthRequest(String mechanism) { + mechanism_ = mechanism; + } + + public AuthRequest(String mechanism, ByteArray message) { + mechanism_ = mechanism; + message_ = message; + } + + public ByteArray getMessage() { + return message_; + } + + public void setMessage(ByteArray message) { + message_ = message; + } + + public String getMechanism() { + return mechanism_; + } + + public void setMechanism(String mechanism) { + mechanism_ = mechanism; + } + private String mechanism_; + private ByteArray message_ = new ByteArray(); +} diff --git a/src/com/isode/stroke/elements/AuthResponse.java b/src/com/isode/stroke/elements/AuthResponse.java new file mode 100644 index 0000000..357b72b --- /dev/null +++ b/src/com/isode/stroke/elements/AuthResponse.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.base.ByteArray; + +public class AuthResponse implements Element { + //FIXME: parser/serialiser + + public AuthResponse() { + value = null; + } + + public AuthResponse(ByteArray value) { + this.value = value; + } + + public ByteArray getValue() { + return value; + } + + public void setValue(ByteArray value) { + this.value = value; + } + private ByteArray value; +} diff --git a/src/com/isode/stroke/elements/AuthSuccess.java b/src/com/isode/stroke/elements/AuthSuccess.java new file mode 100644 index 0000000..eba6b5a --- /dev/null +++ b/src/com/isode/stroke/elements/AuthSuccess.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +import com.isode.stroke.base.ByteArray; + +public class AuthSuccess implements Element { + //FIXME: parser/serialiser + + public ByteArray getValue() { + return value; + } + + public void setValue(ByteArray value) { + this.value = value; + } + private ByteArray value; +} diff --git a/src/com/isode/stroke/elements/Body.java b/src/com/isode/stroke/elements/Body.java new file mode 100644 index 0000000..3cda307 --- /dev/null +++ b/src/com/isode/stroke/elements/Body.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class Body extends Payload { + String text_ = ""; + + public Body() {} + + public Body(String text) { + setText(text); + } + + public void setText(String text) { + text_ = text; + } + + public String getText() { + return text_; + } +} diff --git a/src/com/isode/stroke/elements/CompressFailure.java b/src/com/isode/stroke/elements/CompressFailure.java new file mode 100644 index 0000000..c3a19bd --- /dev/null +++ b/src/com/isode/stroke/elements/CompressFailure.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class CompressFailure implements Element { + +} diff --git a/src/com/isode/stroke/elements/CompressRequest.java b/src/com/isode/stroke/elements/CompressRequest.java new file mode 100644 index 0000000..8150f1d --- /dev/null +++ b/src/com/isode/stroke/elements/CompressRequest.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class CompressRequest implements Element { + + public CompressRequest() { + this(""); + } + + public CompressRequest(String method) { + method_ = method; + } + + public String getMethod() { + return method_; + } + + public void setMethod(String method) { + method_ = method; + } + private String method_; +} diff --git a/src/com/isode/stroke/elements/Compressed.java b/src/com/isode/stroke/elements/Compressed.java new file mode 100644 index 0000000..1309f5b --- /dev/null +++ b/src/com/isode/stroke/elements/Compressed.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class Compressed implements Element { + +} diff --git a/src/com/isode/stroke/elements/Element.java b/src/com/isode/stroke/elements/Element.java new file mode 100644 index 0000000..1b931e4 --- /dev/null +++ b/src/com/isode/stroke/elements/Element.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public interface Element { + +} diff --git a/src/com/isode/stroke/elements/EnableStreamManagement.java b/src/com/isode/stroke/elements/EnableStreamManagement.java new file mode 100644 index 0000000..e551551 --- /dev/null +++ b/src/com/isode/stroke/elements/EnableStreamManagement.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class EnableStreamManagement implements Element { + +} diff --git a/src/com/isode/stroke/elements/ErrorPayload.java b/src/com/isode/stroke/elements/ErrorPayload.java new file mode 100644 index 0000000..913296d --- /dev/null +++ b/src/com/isode/stroke/elements/ErrorPayload.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +/** + * Error. + */ +public class ErrorPayload extends Payload { + private Condition condition_; + private Type type_; + private String text_; + + public enum Type { Cancel, Continue, Modify, Auth, Wait }; + + public enum Condition { + BadRequest, + Conflict, + FeatureNotImplemented, + Forbidden, + Gone, + InternalServerError, + ItemNotFound, + JIDMalformed, + NotAcceptable, + NotAllowed, + NotAuthorized, + PaymentRequired, + RecipientUnavailable, + Redirect, + RegistrationRequired, + RemoteServerNotFound, + RemoteServerTimeout, + ResourceConstraint, + ServiceUnavailable, + SubscriptionRequired, + UndefinedCondition, + UnexpectedRequest + }; + + public ErrorPayload(Condition condition, Type type, String text) { + condition_ = condition; + type_ = type; + text_ = text; + } + + public ErrorPayload(Condition condition, Type type) { + this(condition, type, ""); + } + + public ErrorPayload(Condition condition) { + this(condition, Type.Cancel); + } + + public ErrorPayload() { + this(Condition.UndefinedCondition); + } + + public Type getType() { + return type_; + } + + public void setType(Type type) { + type_ = type; + } + + public Condition getCondition() { + return condition_; + } + + public void setCondition(Condition condition) { + condition_ = condition; + } + + public void setText(String text) { + text_ = text; + } + + public String getText() { + return text_; + } +} diff --git a/src/com/isode/stroke/elements/IQ.java b/src/com/isode/stroke/elements/IQ.java new file mode 100644 index 0000000..a4fc9dc --- /dev/null +++ b/src/com/isode/stroke/elements/IQ.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; + +public class IQ extends Stanza { + public enum Type {Get, Set, Result, Error}; + + private Type type_; + + public IQ() { + this(Type.Get); + } + + public IQ(Type type) { + type_ = type; + } + + public Type getType() { + return type_; + } + + public void setType(Type type) { + type_ = type; + } + + public static IQ createRequest(Type type, JID to, String id, Payload payload) { + IQ iq = new IQ(type); + iq.setTo(to); + iq.setID(id); + iq.addPayload(payload); + return iq; + } + + public static IQ createResult(JID to, String id, Payload payload) { + IQ iq = new IQ(Type.Result); + iq.setTo(to); + iq.setID(id); + iq.addPayload(payload); + return iq; + } + + public static IQ createError(JID to, String id, ErrorPayload.Condition condition, ErrorPayload.Type type) { + IQ iq = new IQ(Type.Error); + iq.setTo(to); + iq.setID(id); + iq.addPayload(new ErrorPayload(condition, type)); + return iq; + } + +} diff --git a/src/com/isode/stroke/elements/Last.java b/src/com/isode/stroke/elements/Last.java new file mode 100644 index 0000000..8f12616 --- /dev/null +++ b/src/com/isode/stroke/elements/Last.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Kevin Smith. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class Last extends Payload { + int seconds_; + + public Last() {} + + public Last(final int seconds) { + setSeconds(seconds); + } + + public void setSeconds(final int seconds) { + seconds_ = seconds; + } + + public int getSeconds() { + return seconds_; + } +} diff --git a/src/com/isode/stroke/elements/Message.java b/src/com/isode/stroke/elements/Message.java new file mode 100644 index 0000000..6820e6f --- /dev/null +++ b/src/com/isode/stroke/elements/Message.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class Message extends Stanza { + + Type type_ = Type.Chat; + + public enum Type { + + Normal, Chat, Error, Groupchat, Headline + }; + + public String getSubject() { + Subject subject = getPayload(new Subject()); + if (subject != null) { + return subject.getText(); + } + return ""; + } + + public void setSubject(String subject) { + updatePayload(new Subject(subject)); + } + + public String getBody() { + Body body = getPayload(new Body()); + if (body != null) { + return body.getText(); + } + return ""; + } + + public void setBody(String body) { + updatePayload(new Body(body)); + } + + public boolean isError() { + ErrorPayload error = getPayload(new ErrorPayload()); + return getType().equals(Type.Error) || error != null; + } + + public Type getType() { + return type_; + } + + public void setType(Type type) { + type_ = type; + } +} diff --git a/src/com/isode/stroke/elements/Payload.java b/src/com/isode/stroke/elements/Payload.java new file mode 100644 index 0000000..fbe47f2 --- /dev/null +++ b/src/com/isode/stroke/elements/Payload.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class Payload { + +} diff --git a/src/com/isode/stroke/elements/Presence.java b/src/com/isode/stroke/elements/Presence.java new file mode 100644 index 0000000..f32fb9f --- /dev/null +++ b/src/com/isode/stroke/elements/Presence.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class Presence extends Stanza { + + private Type type_; + + public enum Type { + + Available, Error, Probe, Subscribe, Subscribed, Unavailable, Unsubscribe, Unsubscribed + }; + + public Presence() { + type_ = Type.Available; + } + + public Presence(String status) { + type_ = Type.Available; + setStatus(status); + } + + public Type getType() { + return type_; + } + + public void setType(Type type) { + type_ = type; + } + + public StatusShow.Type getShow() { + StatusShow show = getPayload (new StatusShow()); + if (show != null) { + return show.getType(); + } + return type_ == Type.Available ? StatusShow.Type.Online : StatusShow.Type.None; + } + + public void setShow(StatusShow.Type show) { + updatePayload(new StatusShow(show)); + } + + public String getStatus() { + Status status = getPayload(new Status()); + if (status != null) { + return status.getText(); + } + return ""; + } + + public void setStatus(String status) { + updatePayload(new Status(status)); + } + + public int getPriority() { + Priority priority = getPayload(new Priority()); + return (priority != null ? priority.getPriority() : 0); + } + + public void setPriority(int priority) { + updatePayload(new Priority(priority)); + } +} diff --git a/src/com/isode/stroke/elements/Priority.java b/src/com/isode/stroke/elements/Priority.java new file mode 100644 index 0000000..850c67a --- /dev/null +++ b/src/com/isode/stroke/elements/Priority.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +/** + * Resource priority from presence stanzas. + */ +public class Priority extends Payload { + int priority_ = 0; + + public Priority(){ + + } + + public Priority (int priority) { + priority_ = priority; + } + + public void setPriority(int priority) { + priority_ = priority; + } + + public int getPriority() { + return priority_; + } +} diff --git a/src/com/isode/stroke/elements/ProtocolHeader.java b/src/com/isode/stroke/elements/ProtocolHeader.java new file mode 100644 index 0000000..16d2925 --- /dev/null +++ b/src/com/isode/stroke/elements/ProtocolHeader.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class ProtocolHeader { + + public ProtocolHeader() { + version = "1.0"; + } + + public String getTo() { + return to; + } + + public void setTo(String a) { + to = a; + } + + public String getFrom() { + return from; + } + + public void setFrom(String a) { + from = a; + } + + public String getVersion() { + return version; + } + + public void setVersion(String a) { + version = a; + } + + public String getID() { + return id; + } + + public void setID(String a) { + id = a; + } + private String to = ""; + private String from = ""; + private String id = ""; + private String version = ""; +} diff --git a/src/com/isode/stroke/elements/RawXMLPayload.java b/src/com/isode/stroke/elements/RawXMLPayload.java new file mode 100644 index 0000000..8c261e9 --- /dev/null +++ b/src/com/isode/stroke/elements/RawXMLPayload.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +/** + * Unparsed content. + */ +public class RawXMLPayload extends Payload { + private String rawXML_; + + public void setRawXML(String data) { + rawXML_ = data; + } + + public String getRawXML() { + return rawXML_; + } +} diff --git a/src/com/isode/stroke/elements/ResourceBind.java b/src/com/isode/stroke/elements/ResourceBind.java new file mode 100644 index 0000000..863ef98 --- /dev/null +++ b/src/com/isode/stroke/elements/ResourceBind.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; + +public class ResourceBind extends Payload { +//FIXME: serializer and parser + public void setJID(JID jid) { + jid_ = jid; + } + + public JID getJID() { + return jid_; + } + + public void setResource(String resource) { + resource_ = resource; + } + + public String getResource() { + return resource_; + } + private JID jid_ = new JID(); + private String resource_ = ""; +} diff --git a/src/com/isode/stroke/elements/RosterItemPayload.java b/src/com/isode/stroke/elements/RosterItemPayload.java new file mode 100644 index 0000000..a80ecc6 --- /dev/null +++ b/src/com/isode/stroke/elements/RosterItemPayload.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; +import java.util.ArrayList; +import java.util.Collection; + +/** + * Roster Items + */ +public class RosterItemPayload { + + public enum Subscription { + + None, To, From, Both, Remove + }; + + public RosterItemPayload() { + subscription_ = Subscription.None; + ask_ = false; + } + + public RosterItemPayload(JID jid, String name, Subscription subscription) { + jid_ = jid; + name_ = name; + subscription_ = subscription; + ask_ = false; + } + + public void setJID(JID jid) { + jid_ = jid; + } + + public JID getJID() { + return jid_; + } + + public void setName(String name) { + name_ = name; + } + + public String getName() { + return name_; + } + + public void setSubscription(Subscription subscription) { + subscription_ = subscription; + } + + public Subscription getSubscription() { + return subscription_; + } + + public void addGroup(String group) { + groups_.add(group); + } + + public void setGroups(Collection<String> groups) { + groups_ = new ArrayList<String>(); + groups_.addAll(groups); + } + + public Collection<String> getGroups() { + return groups_; + } + + public void setSubscriptionRequested() { + ask_ = true; + } + + public boolean getSubscriptionRequested() { + return ask_; + } + private JID jid_; + private String name_; + private Subscription subscription_; + private ArrayList<String> groups_ = new ArrayList<String>(); + private boolean ask_; +} diff --git a/src/com/isode/stroke/elements/RosterPayload.java b/src/com/isode/stroke/elements/RosterPayload.java new file mode 100644 index 0000000..6208216 --- /dev/null +++ b/src/com/isode/stroke/elements/RosterPayload.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; +import java.util.ArrayList; +import java.util.Collection; + +/** + * Roster. + */ +public class RosterPayload extends Payload { + + public RosterPayload() { + } + + public RosterItemPayload getItem(JID jid) { + for (RosterItemPayload item : items_) { + if (item.getJID().equals(jid)) { + return item; + } + } + return null; + } + + public void addItem(RosterItemPayload item) { + items_.add(item); + } + + public Collection<RosterItemPayload> getItems() { + return items_; + } + + private final ArrayList<RosterItemPayload> items_ = new ArrayList<RosterItemPayload>(); +} diff --git a/src/com/isode/stroke/elements/SearchPayload.java b/src/com/isode/stroke/elements/SearchPayload.java new file mode 100644 index 0000000..b8e8a0d --- /dev/null +++ b/src/com/isode/stroke/elements/SearchPayload.java @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; +import java.util.ArrayList; +import java.util.List; + +public class SearchPayload extends Payload { + + public static class Item { + + public String first; + public String last; + public String nick; + public String email; + public JID jid; + }; + + public SearchPayload() { + } + + //Form::ref getForm() const { return form; } /* Not ported yet */ + //void setForm(Form::ref f) { form = f; } /* Not ported yet */ + /** + * @return Can be null + */ + public String getInstructions() { + return instructions; + } + + /** + * @return Can be null + */ + public String getNick() { + return nick; + } + + /** + * @return Can be null + */ + public String getFirst() { + return first; + } + + /** + * @return Can be null + */ + public String getLast() { + return last; + } + + /** + * @return Can be null + */ + public String getEMail() { + return email; + } + + /** + * @param v Null means no value. + */ + public void setInstructions(String v) { + this.instructions = v; + } + + /** + * @param v Null means no value. + */ + public void setNick(String v) { + this.nick = v; + } + + /** + * @param v Null means no value. + */ + public void setFirst(String v) { + this.first = v; + } + + /** + * @param v Null means no value. + */ + public void setLast(String v) { + this.last = v; + } + + /** + * @param v Null means no value. + */ + public void setEMail(String v) { + this.email = v; + } + + /** + * + * @return non-null + */ + public List<Item> getItems() { + return items; + } + + /** + * + * @param item Non-null. + */ + public void addItem(Item item) { + items.add(item); + } + + //private Form::ref form; /*Not ported yet*/ + private String instructions; + private String nick; + private String first; + private String last; + private String email; + private ArrayList<Item> items = new ArrayList<Item>(); +} diff --git a/src/com/isode/stroke/elements/Stanza.java b/src/com/isode/stroke/elements/Stanza.java new file mode 100644 index 0000000..ac4f06f --- /dev/null +++ b/src/com/isode/stroke/elements/Stanza.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +import com.isode.stroke.jid.JID; +import java.util.Vector; + +/** + * Basic XMPP stanza. + */ +public class Stanza implements Element { + private String id_; + private JID from_; + private JID to_; + private Vector<Payload> payloads_ = new Vector<Payload>(); + + + public <T extends Payload> T getPayload(T type) { + for (Payload payload : payloads_) { + if (payload.getClass().isAssignableFrom(type.getClass())) { + return (T)payload; + } + } + return null; + } + + public <T extends Payload> Vector<T> getPayloads(T type) { + Vector<T> results = new Vector<T>(); + for (Payload payload : payloads_) { + if (payload.getClass().isAssignableFrom(type.getClass())) { + results.add((T)payload); + } + } + return results; + } + + public Vector<Payload> getPayloads() { + return payloads_; + } + + public void addPayload(Payload payload) { + payloads_.add(payload); + } + + public void updatePayload(Payload payload) { + for (int i = 0; i < payloads_.size(); i++) { + if (payloads_.get(i).getClass() == payload.getClass()) { + payloads_.set(i, payload); + return; + } + } + payloads_.add(payload); + } + + public JID getFrom() { + return from_; + } + + public void setFrom(JID from) { + from_ = from; + } + + public JID getTo() { + return to_; + } + + public void setTo(JID to) { + to_ = to; + } + + public String getID() { + return id_; + } + + public void setID(String id) { + id_ = id; + } + +} diff --git a/src/com/isode/stroke/elements/StanzaAck.java b/src/com/isode/stroke/elements/StanzaAck.java new file mode 100644 index 0000000..0589d39 --- /dev/null +++ b/src/com/isode/stroke/elements/StanzaAck.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StanzaAck implements Element { + //FIXME: parser/serialiser + public StanzaAck() { + } + + public StanzaAck(long handledStanzasCount) { + valid = true; + this.handledStanzasCount = handledStanzasCount; + } + + public long getHandledStanzasCount() { + return handledStanzasCount; + } + + public void setHandledStanzasCount(long i) { + handledStanzasCount = i; + valid = true; + } + + public boolean isValid() { + return valid; + } + private boolean valid = false; + private long handledStanzasCount = 0; +} diff --git a/src/com/isode/stroke/elements/StanzaAckRequest.java b/src/com/isode/stroke/elements/StanzaAckRequest.java new file mode 100644 index 0000000..b02ac4e --- /dev/null +++ b/src/com/isode/stroke/elements/StanzaAckRequest.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class StanzaAckRequest implements Element { + +} diff --git a/src/com/isode/stroke/elements/StartSession.java b/src/com/isode/stroke/elements/StartSession.java new file mode 100644 index 0000000..b886535 --- /dev/null +++ b/src/com/isode/stroke/elements/StartSession.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class StartSession extends Payload{ + +} diff --git a/src/com/isode/stroke/elements/StartTLSFailure.java b/src/com/isode/stroke/elements/StartTLSFailure.java new file mode 100644 index 0000000..7b18dfe --- /dev/null +++ b/src/com/isode/stroke/elements/StartTLSFailure.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class StartTLSFailure implements Element { + + //FIXME: parser/serialiser + +} diff --git a/src/com/isode/stroke/elements/StartTLSRequest.java b/src/com/isode/stroke/elements/StartTLSRequest.java new file mode 100644 index 0000000..23c3297 --- /dev/null +++ b/src/com/isode/stroke/elements/StartTLSRequest.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.elements; + + +public class StartTLSRequest implements Element { +//FIXME: parser/serialiser + +} diff --git a/src/com/isode/stroke/elements/Status.java b/src/com/isode/stroke/elements/Status.java new file mode 100644 index 0000000..f40814d --- /dev/null +++ b/src/com/isode/stroke/elements/Status.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class Status extends Payload { + + String text_ = ""; + + public Status() { + } + + public Status(String text) { + text_ = text; + } + + public void setText(String text) { + text_ = text; + } + + public String getText() { + return text_; + } +} diff --git a/src/com/isode/stroke/elements/StatusShow.java b/src/com/isode/stroke/elements/StatusShow.java new file mode 100644 index 0000000..d7f8575 --- /dev/null +++ b/src/com/isode/stroke/elements/StatusShow.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StatusShow extends Payload { + + private Type type_; + + public enum Type { + + Online, Away, FFC, XA, DND, None + }; + + public StatusShow() { + type_ = Type.Online; + } + + public StatusShow(Type type) { + type_ = type; + } + + void setType(Type type) { + type_ = type; + } + + Type getType() { + return type_; + } + + static String typeToFriendlyName(Type type) { + switch (type) { + case Online: + return "Available"; + case FFC: + return "Available"; + case Away: + return "Away"; + case XA: + return "Away"; + case DND: + return "Busy"; + case None: + return "Offline"; + } + return "Unknown"; + } +} diff --git a/src/com/isode/stroke/elements/StreamError.java b/src/com/isode/stroke/elements/StreamError.java new file mode 100644 index 0000000..9335ddb --- /dev/null +++ b/src/com/isode/stroke/elements/StreamError.java @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StreamError implements Element { + + public enum Type { + + BadFormat, + BadNamespacePrefix, + Conflict, + ConnectionTimeout, + HostGone, + HostUnknown, + ImproperAddressing, + InternalServerError, + InvalidFrom, + InvalidID, + InvalidNamespace, + InvalidXML, + NotAuthorized, + NotWellFormed, + PolicyViolation, + RemoteConnectionFailed, + Reset, + ResourceConstraint, + RestrictedXML, + SeeOtherHost, + SystemShutdown, + UndefinedCondition, + UnsupportedEncoding, + UnsupportedStanzaType, + UnsupportedVersion, + }; + + public StreamError() { + this(Type.UndefinedCondition); + } + + public StreamError(Type type) { + this(type, ""); + } + + public StreamError(Type type, String text) { + if (type == null) { + throw new IllegalStateException(); + } + type_ = type; + text_ = text; + } + + public Type getType() { + return type_; + } + + public void setType(Type type) { + type_ = type; + } + + public void setText(String text) { + text_ = text; + } + + public String getText() { + return text_; + } + private Type type_; + private String text_; +}; diff --git a/src/com/isode/stroke/elements/StreamFeatures.java b/src/com/isode/stroke/elements/StreamFeatures.java new file mode 100644 index 0000000..c784077 --- /dev/null +++ b/src/com/isode/stroke/elements/StreamFeatures.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron?on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +//FIXME: parser/serialiser +import java.util.ArrayList; +import java.util.Collection; + +public class StreamFeatures implements Element { + + public StreamFeatures() { + hasStartTLS_ = false; + hasResourceBind_ = false; + hasSession_ = false; + hasStreamManagement_ = false; + } + + public void setHasStartTLS() { + hasStartTLS_ = true; + } + + public boolean hasStartTLS() { + return hasStartTLS_; + } + + public void setHasSession() { + hasSession_ = true; + } + + public boolean hasSession() { + return hasSession_; + } + + public void setHasResourceBind() { + hasResourceBind_ = true; + } + + public boolean hasResourceBind() { + return hasResourceBind_; + } + + public Collection<String> getCompressionMethods() { + return compressionMethods_; + } + + public void addCompressionMethod(String mechanism) { + compressionMethods_.add(mechanism); + } + + public boolean hasCompressionMethod(String mechanism) { + return compressionMethods_.contains(mechanism); + } + + public Collection<String> getAuthenticationMechanisms() { + return authenticationMechanisms_; + } + + public void addAuthenticationMechanism(String mechanism) { + authenticationMechanisms_.add(mechanism); + } + + public boolean hasAuthenticationMechanism(String mechanism) { + return authenticationMechanisms_.contains(mechanism); + } + + public boolean hasAuthenticationMechanisms() { + return !authenticationMechanisms_.isEmpty(); + } + + public boolean hasStreamManagement() { + return hasStreamManagement_; + } + + public void setHasStreamManagement() { + hasStreamManagement_ = true; + } + + public boolean hasRosterVersioning() { + return hasRosterVersioning_; + } + + public void setHasRosterVersioning() { + hasRosterVersioning_ = true; + } + + private boolean hasStartTLS_; + private ArrayList<String> compressionMethods_ = new ArrayList<String>(); + private ArrayList<String> authenticationMechanisms_ = new ArrayList<String>(); + private boolean hasResourceBind_; + private boolean hasSession_; + private boolean hasStreamManagement_; + private boolean hasRosterVersioning_; +} diff --git a/src/com/isode/stroke/elements/StreamManagementEnabled.java b/src/com/isode/stroke/elements/StreamManagementEnabled.java new file mode 100644 index 0000000..db2aa77 --- /dev/null +++ b/src/com/isode/stroke/elements/StreamManagementEnabled.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StreamManagementEnabled implements Element { + + public void setResumeSupported() { + resumeSupported = true; + } + + public boolean getResumeSupported() { + return resumeSupported; + } + + public void setResumeID(String id) { + resumeID = id; + } + + public String getResumeID() { + return resumeID; + } + private boolean resumeSupported; + private String resumeID; +} diff --git a/src/com/isode/stroke/elements/StreamManagementFailed.java b/src/com/isode/stroke/elements/StreamManagementFailed.java new file mode 100644 index 0000000..7be357b --- /dev/null +++ b/src/com/isode/stroke/elements/StreamManagementFailed.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class StreamManagementFailed implements Element { + +} diff --git a/src/com/isode/stroke/elements/StreamResume.java b/src/com/isode/stroke/elements/StreamResume.java new file mode 100644 index 0000000..40c6326 --- /dev/null +++ b/src/com/isode/stroke/elements/StreamResume.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StreamResume implements Element { + + public void setResumeID(String id) { + resumeID = id; + } + + public String getResumeID() { + return resumeID; + } + + public Long getHandledStanzasCount() { + return handledStanzasCount; + } + + public void setHandledStanzasCount(long i) { + handledStanzasCount = i; + } + private String resumeID; + private Long handledStanzasCount; +} diff --git a/src/com/isode/stroke/elements/StreamResumed.java b/src/com/isode/stroke/elements/StreamResumed.java new file mode 100644 index 0000000..23f0e54 --- /dev/null +++ b/src/com/isode/stroke/elements/StreamResumed.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.elements; + +public class StreamResumed implements Element { + + public void setResumeID(String id) { + resumeID = id; + } + + public String getResumeID() { + return resumeID; + } + + public Long getHandledStanzasCount() { + return handledStanzasCount; + } + + public void setHandledStanzasCount(long i) { + handledStanzasCount = i; + } + private String resumeID; + private Long handledStanzasCount; +} diff --git a/src/com/isode/stroke/elements/StreamType.java b/src/com/isode/stroke/elements/StreamType.java new file mode 100644 index 0000000..4ec7d9f --- /dev/null +++ b/src/com/isode/stroke/elements/StreamType.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + + +public enum StreamType { + ClientStreamType, + ServerStreamType, + ComponentStreamType +} diff --git a/src/com/isode/stroke/elements/Subject.java b/src/com/isode/stroke/elements/Subject.java new file mode 100644 index 0000000..0881a26 --- /dev/null +++ b/src/com/isode/stroke/elements/Subject.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class Subject extends Payload { + String text_ = ""; + + public Subject() {} + + public Subject(String text) { + setText(text); + } + + public void setText(String text) { + text_ = text; + } + + public String getText() { + return text_; + } +} diff --git a/src/com/isode/stroke/elements/TLSProceed.java b/src/com/isode/stroke/elements/TLSProceed.java new file mode 100644 index 0000000..d330364 --- /dev/null +++ b/src/com/isode/stroke/elements/TLSProceed.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + + +public class TLSProceed implements Element { +//FIXME: parser/serialiser +} diff --git a/src/com/isode/stroke/elements/UnknownElement.java b/src/com/isode/stroke/elements/UnknownElement.java new file mode 100644 index 0000000..c9d1f4f --- /dev/null +++ b/src/com/isode/stroke/elements/UnknownElement.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.elements; + +public class UnknownElement implements Element { + +} diff --git a/src/com/isode/stroke/elements/Version.java b/src/com/isode/stroke/elements/Version.java new file mode 100644 index 0000000..80c1af3 --- /dev/null +++ b/src/com/isode/stroke/elements/Version.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.elements; + + +public class Version extends Payload { + private String name_; + private String version_; + private String os_; + + public Version(final String name, final String version, final String os) { + name_ = name; + version_ = version; + os_ = os; + } + + public Version() { + + } + + public String getName() { + return name_; + } + + public String getVersion() { + return version_; + } + + public String getOS() { + return os_; + } + + public void setName(final String name) { + name_ = name; + } + + public void setVersion(final String version) { + version_ = version; + } + + public void setOS(final String os) { + os_ = os; + } +} diff --git a/src/com/isode/stroke/eventloop/Event.java b/src/com/isode/stroke/eventloop/Event.java new file mode 100644 index 0000000..b3c8c00 --- /dev/null +++ b/src/com/isode/stroke/eventloop/Event.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.eventloop; + +public class Event { + + public interface Callback { + + void run(); + } + + Event(EventOwner owner, Callback callback, int id) { + this.owner = owner; + this.callback = callback; + this.id = id; + } + + @Override + public boolean equals(Object other) { + if (other instanceof Event) { + return id == ((Event) other).id; + } + return false; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 23 * hash + this.id; + return hash; + } + final int id; + final EventOwner owner; + public final Callback callback; +} diff --git a/src/com/isode/stroke/eventloop/EventLoop.java b/src/com/isode/stroke/eventloop/EventLoop.java new file mode 100644 index 0000000..9399d9a --- /dev/null +++ b/src/com/isode/stroke/eventloop/EventLoop.java @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.eventloop; + +import java.util.ArrayList; +import java.util.Vector; + +public abstract class EventLoop { + + public EventLoop() { + } + + public void postEvent(Event.Callback callback) { + postEvent(callback, null); + } + + public void postEvent(Event.Callback callback, EventOwner owner) { + Event event; + synchronized (eventsMutex_) { + event = new Event(owner, callback, nextEventID_); + nextEventID_++; + events_.add(event); + } + post(event); + } + + public void removeEventsFromOwner(EventOwner owner) { + synchronized (eventsMutex_) { + ArrayList<Event> matches = new ArrayList<Event>(); + for (Event event : events_) { + if (event.owner == owner) { + matches.add(event); + } + } + events_.removeAll(matches); + } + } + + /** + * Reimplement this to call handleEvent(event) from the thread in which + * the event loop is residing. + */ + protected abstract void post(Event event); + + protected void handleEvent(Event event) { + if (handlingEvents_) { + // We're being called recursively. Push in the list of events to + // handle in the parent handleEvent() + eventsToHandle_.add(event); + return; + } + + boolean doCallback = false; + synchronized (eventsMutex_) { + doCallback = events_.contains(event); + if (doCallback) { + events_.remove(event); + } + } + if (doCallback) { + handlingEvents_ = true; + event.callback.run(); + // Process events that were passed to handleEvent during the callback + // (i.e. through recursive calls of handleEvent) + while (!eventsToHandle_.isEmpty()) { + Event nextEvent = eventsToHandle_.firstElement(); + eventsToHandle_.remove(0); + nextEvent.callback.run(); + } + handlingEvents_ = false; + } + } + // struct HasOwner { + // HasOwner(boost::shared_ptr<EventOwner> owner) : owner(owner) {} + // bool operator()(const Event& event) { return event.owner == owner; } + // boost::shared_ptr<EventOwner> owner; + // }; + private final Object eventsMutex_ = new Object(); + private int nextEventID_ = 0; + private Vector<Event> events_ = new Vector<Event>(); + boolean handlingEvents_ = false; + private Vector<Event> eventsToHandle_ = new Vector<Event>(); +} diff --git a/src/com/isode/stroke/eventloop/EventOwner.java b/src/com/isode/stroke/eventloop/EventOwner.java new file mode 100644 index 0000000..305ab1a --- /dev/null +++ b/src/com/isode/stroke/eventloop/EventOwner.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.eventloop; + +public interface EventOwner { + +} diff --git a/src/com/isode/stroke/eventloop/SimpleEventLoop.java b/src/com/isode/stroke/eventloop/SimpleEventLoop.java new file mode 100644 index 0000000..003fc98 --- /dev/null +++ b/src/com/isode/stroke/eventloop/SimpleEventLoop.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.eventloop; + +/** + * Don't use this, it simply runs the callback in the same thread. + * It is useful for unit testing, but will break GUIs. + */ +public class SimpleEventLoop extends EventLoop { + @Override + protected void post(Event event) { + event.callback.run(); + } +} diff --git a/src/com/isode/stroke/examples/gui/StrokeGUI.form b/src/com/isode/stroke/examples/gui/StrokeGUI.form new file mode 100644 index 0000000..502e00b --- /dev/null +++ b/src/com/isode/stroke/examples/gui/StrokeGUI.form @@ -0,0 +1,201 @@ +<?xml version="1.0" encoding="UTF-8" ?> + +<Form version="1.3" maxVersion="1.7" type="org.netbeans.modules.form.forminfo.JFrameFormInfo"> + <Properties> + <Property name="defaultCloseOperation" type="int" value="3"/> + </Properties> + <SyntheticProperties> + <SyntheticProperty name="formSizePolicy" type="int" value="1"/> + </SyntheticProperties> + <AuxValues> + <AuxValue name="FormSettings_autoResourcing" type="java.lang.Integer" value="0"/> + <AuxValue name="FormSettings_autoSetComponentName" type="java.lang.Boolean" value="false"/> + <AuxValue name="FormSettings_generateFQN" type="java.lang.Boolean" value="true"/> + <AuxValue name="FormSettings_generateMnemonicsCode" type="java.lang.Boolean" value="false"/> + <AuxValue name="FormSettings_i18nAutoMode" type="java.lang.Boolean" value="false"/> + <AuxValue name="FormSettings_layoutCodeTarget" type="java.lang.Integer" value="2"/> + <AuxValue name="FormSettings_listenerGenerationStyle" type="java.lang.Integer" value="0"/> + <AuxValue name="FormSettings_variablesLocal" type="java.lang.Boolean" value="false"/> + <AuxValue name="FormSettings_variablesModifier" type="java.lang.Integer" value="2"/> + <AuxValue name="designerSize" type="java.awt.Dimension" value="-84,-19,0,5,115,114,0,18,106,97,118,97,46,97,119,116,46,68,105,109,101,110,115,105,111,110,65,-114,-39,-41,-84,95,68,20,2,0,2,73,0,6,104,101,105,103,104,116,73,0,5,119,105,100,116,104,120,112,0,0,4,60,0,0,3,46"/> + </AuxValues> + + <Layout class="org.netbeans.modules.form.compat2.layouts.DesignFlowLayout"/> + <SubComponents> + <Container class="javax.swing.JPanel" name="jPanel1"> + <Properties> + <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor"> + <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo"> + <TitledBorder title="Login Stuff"/> + </Border> + </Property> + </Properties> + + <Layout class="org.netbeans.modules.form.compat2.layouts.DesignFlowLayout"/> + <SubComponents> + <Component class="javax.swing.JLabel" name="jLabel1"> + <Properties> + <Property name="text" type="java.lang.String" value="JID"/> + </Properties> + </Component> + <Component class="javax.swing.JTextField" name="loginJID_"> + <Properties> + <Property name="bounds" type="java.awt.Rectangle" editor="org.netbeans.beaninfo.editors.RectangleEditor"> + <Rectangle value="[0, 0, 150, 0]"/> + </Property> + <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[150, 28]"/> + </Property> + <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[250, 28]"/> + </Property> + </Properties> + </Component> + <Component class="javax.swing.JLabel" name="jLabel2"> + <Properties> + <Property name="text" type="java.lang.String" value="Password"/> + </Properties> + </Component> + <Component class="javax.swing.JTextField" name="loginPassword_"> + <Properties> + <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[100, 28]"/> + </Property> + <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[150, 28]"/> + </Property> + </Properties> + </Component> + <Component class="javax.swing.JButton" name="loginButton_"> + <Properties> + <Property name="text" type="java.lang.String" value="Login"/> + </Properties> + <Events> + <EventHandler event="actionPerformed" listener="java.awt.event.ActionListener" parameters="java.awt.event.ActionEvent" handler="loginButton_ActionPerformed"/> + </Events> + </Component> + </SubComponents> + </Container> + <Container class="javax.swing.JPanel" name="jPanel2"> + <Properties> + <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor"> + <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo"> + <TitledBorder title="Send Stuff"/> + </Border> + </Property> + </Properties> + + <Layout class="org.netbeans.modules.form.compat2.layouts.DesignFlowLayout"/> + <SubComponents> + <Component class="javax.swing.JTextField" name="sendTo_"> + <Properties> + <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[150, 28]"/> + </Property> + <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[250, 28]"/> + </Property> + </Properties> + </Component> + <Component class="javax.swing.JLabel" name="jLabel3"> + <Properties> + <Property name="text" type="java.lang.String" value="To"/> + </Properties> + </Component> + <Component class="javax.swing.JButton" name="sendButton_"> + <Properties> + <Property name="text" type="java.lang.String" value="Send"/> + </Properties> + <Events> + <EventHandler event="actionPerformed" listener="java.awt.event.ActionListener" parameters="java.awt.event.ActionEvent" handler="sendButton_ActionPerformed"/> + </Events> + </Component> + <Container class="javax.swing.JScrollPane" name="jScrollPane1"> + <AuxValues> + <AuxValue name="autoScrollPane" type="java.lang.Boolean" value="true"/> + </AuxValues> + + <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/> + <SubComponents> + <Component class="javax.swing.JTextArea" name="sendText_"> + <Properties> + <Property name="columns" type="int" value="20"/> + <Property name="rows" type="int" value="5"/> + <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[150, 16]"/> + </Property> + <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[150, 150]"/> + </Property> + <Property name="size" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[450, 150]"/> + </Property> + </Properties> + </Component> + </SubComponents> + </Container> + </SubComponents> + </Container> + <Container class="javax.swing.JPanel" name="jPanel3"> + <Properties> + <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor"> + <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo"> + <TitledBorder title="Receive Stuff"/> + </Border> + </Property> + </Properties> + + <Layout class="org.netbeans.modules.form.compat2.layouts.DesignFlowLayout"/> + <SubComponents> + <Container class="javax.swing.JScrollPane" name="jScrollPane2"> + <AuxValues> + <AuxValue name="autoScrollPane" type="java.lang.Boolean" value="true"/> + </AuxValues> + + <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/> + <SubComponents> + <Component class="javax.swing.JTextArea" name="receiveText_"> + <Properties> + <Property name="columns" type="int" value="20"/> + <Property name="editable" type="boolean" value="false"/> + <Property name="rows" type="int" value="5"/> + </Properties> + </Component> + </SubComponents> + </Container> + </SubComponents> + </Container> + <Container class="javax.swing.JPanel" name="jPanel4"> + <Properties> + <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor"> + <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo"> + <TitledBorder title="XML"/> + </Border> + </Property> + </Properties> + + <Layout class="org.netbeans.modules.form.compat2.layouts.DesignFlowLayout"/> + <SubComponents> + <Container class="javax.swing.JScrollPane" name="jScrollPane3"> + <AuxValues> + <AuxValue name="autoScrollPane" type="java.lang.Boolean" value="true"/> + </AuxValues> + + <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/> + <SubComponents> + <Component class="javax.swing.JTextArea" name="xmlText_"> + <Properties> + <Property name="columns" type="int" value="20"/> + <Property name="editable" type="boolean" value="false"/> + <Property name="rows" type="int" value="5"/> + <Property name="size" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor"> + <Dimension value="[500, 300]"/> + </Property> + </Properties> + </Component> + </SubComponents> + </Container> + </SubComponents> + </Container> + </SubComponents> +</Form> diff --git a/src/com/isode/stroke/examples/gui/StrokeGUI.java b/src/com/isode/stroke/examples/gui/StrokeGUI.java new file mode 100644 index 0000000..09f7936 --- /dev/null +++ b/src/com/isode/stroke/examples/gui/StrokeGUI.java @@ -0,0 +1,247 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ + +/* + * MainFrame.java + * + * Created on Jul 7, 2010, 10:03:01 AM + */ + +package com.isode.stroke.examples.gui; + +import com.isode.stroke.client.ClientError; +import com.isode.stroke.client.ClientOptions; +import com.isode.stroke.client.CoreClient; +import com.isode.stroke.elements.Message; +import com.isode.stroke.eventloop.Event; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.jid.JID; +import com.isode.stroke.network.JavaNetworkFactories; +import com.isode.stroke.signals.Slot1; +import java.awt.EventQueue; + +public class StrokeGUI extends javax.swing.JFrame { + + private CoreClient client_; + + /** Creates new form MainFrame */ + public StrokeGUI() { + initComponents(); + } + + /** This method is called from within the constructor to + * initialize the form. + * WARNING: Do NOT modify this code. The content of this method is + * always regenerated by the Form Editor. + */ + @SuppressWarnings("unchecked") + // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents + private void initComponents() { + + jPanel1 = new javax.swing.JPanel(); + jLabel1 = new javax.swing.JLabel(); + loginJID_ = new javax.swing.JTextField(); + jLabel2 = new javax.swing.JLabel(); + loginPassword_ = new javax.swing.JTextField(); + loginButton_ = new javax.swing.JButton(); + jPanel2 = new javax.swing.JPanel(); + sendTo_ = new javax.swing.JTextField(); + jLabel3 = new javax.swing.JLabel(); + sendButton_ = new javax.swing.JButton(); + jScrollPane1 = new javax.swing.JScrollPane(); + sendText_ = new javax.swing.JTextArea(); + jPanel3 = new javax.swing.JPanel(); + jScrollPane2 = new javax.swing.JScrollPane(); + receiveText_ = new javax.swing.JTextArea(); + jPanel4 = new javax.swing.JPanel(); + jScrollPane3 = new javax.swing.JScrollPane(); + xmlText_ = new javax.swing.JTextArea(); + + setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); + getContentPane().setLayout(new java.awt.FlowLayout()); + + jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Login Stuff")); + + jLabel1.setText("JID"); + jPanel1.add(jLabel1); + + loginJID_.setBounds(new java.awt.Rectangle(0, 0, 150, 0)); + loginJID_.setMinimumSize(new java.awt.Dimension(150, 28)); + loginJID_.setPreferredSize(new java.awt.Dimension(250, 28)); + jPanel1.add(loginJID_); + + jLabel2.setText("Password"); + jPanel1.add(jLabel2); + + loginPassword_.setMinimumSize(new java.awt.Dimension(100, 28)); + loginPassword_.setPreferredSize(new java.awt.Dimension(150, 28)); + jPanel1.add(loginPassword_); + + loginButton_.setText("Login"); + loginButton_.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + loginButton_ActionPerformed(evt); + } + }); + jPanel1.add(loginButton_); + + getContentPane().add(jPanel1); + + jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Send Stuff")); + + sendTo_.setMinimumSize(new java.awt.Dimension(150, 28)); + sendTo_.setPreferredSize(new java.awt.Dimension(250, 28)); + jPanel2.add(sendTo_); + + jLabel3.setText("To"); + jPanel2.add(jLabel3); + + sendButton_.setText("Send"); + sendButton_.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + sendButton_ActionPerformed(evt); + } + }); + jPanel2.add(sendButton_); + + sendText_.setColumns(20); + sendText_.setRows(5); + sendText_.setMinimumSize(new java.awt.Dimension(150, 16)); + sendText_.setPreferredSize(new java.awt.Dimension(150, 150)); + sendText_.setSize(new java.awt.Dimension(450, 150)); + jScrollPane1.setViewportView(sendText_); + + jPanel2.add(jScrollPane1); + + getContentPane().add(jPanel2); + + jPanel3.setBorder(javax.swing.BorderFactory.createTitledBorder("Receive Stuff")); + + receiveText_.setColumns(20); + receiveText_.setEditable(false); + receiveText_.setRows(5); + jScrollPane2.setViewportView(receiveText_); + + jPanel3.add(jScrollPane2); + + getContentPane().add(jPanel3); + + jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder("XML")); + + xmlText_.setColumns(20); + xmlText_.setEditable(false); + xmlText_.setRows(5); + xmlText_.setSize(new java.awt.Dimension(500, 300)); + jScrollPane3.setViewportView(xmlText_); + + jPanel4.add(jScrollPane3); + + getContentPane().add(jPanel4); + jPanel4.getAccessibleContext().setAccessibleName("XML"); + + pack(); + }// </editor-fold>//GEN-END:initComponents + + private void loginButton_ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_loginButton_ActionPerformed + System.out.println("Client created from JID " + loginJID_.getText()); + EventLoop eventLoop = new EventLoop() { + @Override + protected void post(final Event event) { + EventQueue.invokeLater(new Runnable() { + public void run() { + event.callback.run(); + } + }); + } + + }; + client_ = new CoreClient(eventLoop, JID.fromString(loginJID_.getText()), loginPassword_.getText(), new JavaNetworkFactories(eventLoop)); + System.out.println("Connecting"); + try { + client_.connect(new ClientOptions()); + } catch (Exception e) { + //Something bad happened + System.out.println("Exception!"); + } + System.out.println("Connected"); + final StrokeGUI thisObject = this; + client_.onMessageReceived.connect(new Slot1<Message>() { + + public void call(Message p1) { + thisObject.handleMessageReceived(p1); + } + }); + client_.onError.connect(new Slot1<ClientError>() { + + public void call(ClientError p1) { + thisObject.handleClientError(p1); + } + }); + client_.onDataRead.connect(new Slot1<String>() { + + public void call(String p1) { + xmlText_.append(">>> " + p1 + "\n"); + } + }); + client_.onDataWritten.connect(new Slot1<String>() { + + public void call(String p1) { + xmlText_.append("<<< " + p1 + "\n"); + } + }); + }//GEN-LAST:event_loginButton_ActionPerformed + + private void sendButton_ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_sendButton_ActionPerformed + Message message = new Message(); + message.setTo(JID.fromString(sendTo_.getText())); + message.setBody(sendText_.getText()); + System.out.println("Message body is " + message.getBody()); + client_.sendMessage(message); + + }//GEN-LAST:event_sendButton_ActionPerformed + + /** + * @param args the command line arguments + */ + public static void main(String args[]) { + java.awt.EventQueue.invokeLater(new Runnable() { + public void run() { + new StrokeGUI().setVisible(true); + } + }); + } + + // Variables declaration - do not modify//GEN-BEGIN:variables + private javax.swing.JLabel jLabel1; + private javax.swing.JLabel jLabel2; + private javax.swing.JLabel jLabel3; + private javax.swing.JPanel jPanel1; + private javax.swing.JPanel jPanel2; + private javax.swing.JPanel jPanel3; + private javax.swing.JPanel jPanel4; + private javax.swing.JScrollPane jScrollPane1; + private javax.swing.JScrollPane jScrollPane2; + private javax.swing.JScrollPane jScrollPane3; + private javax.swing.JButton loginButton_; + private javax.swing.JTextField loginJID_; + private javax.swing.JTextField loginPassword_; + private javax.swing.JTextArea receiveText_; + private javax.swing.JButton sendButton_; + private javax.swing.JTextArea sendText_; + private javax.swing.JTextField sendTo_; + private javax.swing.JTextArea xmlText_; + // End of variables declaration//GEN-END:variables + + private void handleMessageReceived(Message message) { + String from = message.getFrom().toString(); + String body = message.getBody(); + receiveText_.append("<" + from + "> " + body + "\n"); + } + + private void handleClientError(ClientError error) { + receiveText_.append("Error connecting to server\n"); + } + +} diff --git a/src/com/isode/stroke/idn/IDNA.java b/src/com/isode/stroke/idn/IDNA.java new file mode 100644 index 0000000..e180cc5 --- /dev/null +++ b/src/com/isode/stroke/idn/IDNA.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.idn; + +import java.net.IDN; + +public class IDNA { + public static String getEncoded(String s) { + return IDN.toASCII(s); + } +} diff --git a/src/com/isode/stroke/jid/JID.java b/src/com/isode/stroke/jid/JID.java new file mode 100644 index 0000000..70c2ccc --- /dev/null +++ b/src/com/isode/stroke/jid/JID.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.jid; + +/** + * JID helper. + * + * This represents the JID used in XMPP + * (RFC6120 - http://tools.ietf.org/html/rfc6120 particularly section 1.4), + * further defined in XMPP Address Format (http://tools.ietf.org/html/rfc6122 ). + * For a description of format, see the RFC or page 14 of + * XMPP: The Definitive Guide (Saint-Andre et al.) + * + * Particularly - a Bare JID is a JID without a resource part. + * + * Note that invalid JIDs shouldn't have any calls made to them beyond isValid(). + * + */ +public class JID { + public enum CompareType { + WithResource, WithoutResource + }; + + private final String node_; + private final String domain_; + private final String resource_; + + /** + * Create an invalid JID. + */ + public JID() { + this("", "", null); + } + + /** + * Create a JID using the JID(String) constructor. + * @param jid String formatted JID. + */ + public static JID fromString(final String jid) { + return new JID(jid); + } + + /** + * Create a JID from its String representation. + * + * e.g. + * wonderland.lit + * wonderland.lit/rabbithole + * alice@wonderland.lit + * alice@wonderland.lit/TeaParty + * + * @param jid String representation. Invalid JID if null or invalid. + */ + public JID(final String jid) { + //FIXME: This doesn't nameprep! + if (jid == null || jid.startsWith("@")) { + node_ = ""; + domain_ = ""; + resource_ = ""; + return; + } + + String bare; + String resource; + String[] parts = jid.split("/", 2); + if (parts.length > 1) { + bare = parts[0]; + resource = parts[1]; + } else { + resource = null; + bare = jid; + } + String[] nodeAndDomain = bare.split("@", 2); + if (nodeAndDomain.length == 1) { + node_ = ""; + domain_ = nodeAndDomain[0]; + resource_ = resource; + } else { + node_ = nodeAndDomain[0]; + domain_ = nodeAndDomain[1]; + resource_ = resource; + } + + } + + /** + * Create a bare JID from the node and domain parts. + * + * JID("node@domain") == JID("node", "domain") + * Use a different constructor instead of passing nulls. + * + * @param node JID node part. + * @param domain JID domain part. + */ + public JID(final String node, final String domain) { + this(node, domain, null); + } + + /** + * Create a bare JID from the node, domain and resource parts. + * + * JID("node@domain/resource") == JID("node", "domain", "resource") + * Use a different constructor instead of passing nulls. + * + * @param node JID node part. + * @param domain JID domain part. + * @param resource JID resource part. + */ + public JID(final String node, final String domain, final String resource) { + //FIXME: This doesn't nameprep! + node_ = node; + domain_ = domain; + resource_ = resource; + + } + + /** + * @return Is a correctly-formatted JID. + */ + public boolean isValid() { + return (domain_.length()!=0); + } + + /** + * e.g. JID("node@domain").getNode() == "node" + * @return null for nodeless JIDs. + */ + public String getNode() { + return node_; + } + + /** + * e.g. JID("node@domain").getDomain() == "domain" + * @return only null for invalid JIDs. + */ + public String getDomain() { + return domain_; + } + + /** + * e.g. JID("node@domain/resource").getResource() == "resource" + * @return null for bare JIDs. + */ + public String getResource() { + return resource_ != null ? resource_ : ""; + } + + /** + * Is a bare JID, i.e. has no resource part. + */ + public boolean isBare() { + return resource_ == null; + } + + /** + * Get the JID without a resource. + * @return non-null. Invalid if the original is invalid. + */ + public JID toBare() { + return new JID(getNode(), getDomain()); + } + + @Override + public String toString() { + String string = new String(); + if (node_.length()!=0) { + string += node_ + "@"; + } + string += domain_; + if (!isBare()) { + string += "/" + resource_; + } + return string; + } + + @Override + public boolean equals(final Object otherObject) { + if (otherObject == null || getClass() != otherObject.getClass()) { + return false; + } + if (otherObject == this) { + return true; + } + JID other = (JID)otherObject; + String node1 = getNode(); + String node2 = other.getNode(); + String domain1 = getDomain(); + String domain2 = other.getDomain(); + String resource1 = getResource(); + String resource2 = other.getResource(); + boolean nodeMatch = (node1 == null && node2 == null) || (node1 != null && node1.equals(node2)); + boolean domainMatch = (domain1 == null && domain2 == null) || (domain1 != null && domain1.equals(domain2)); + boolean resourceMatch = (resource1 == null && resource2 == null) || (resource1 != null && resource1.equals(resource2)); + return nodeMatch && domainMatch && resourceMatch; + } + + @Override + public int hashCode() { + int hash = 5; + hash = 73 * hash + (this.node_ != null ? this.node_.hashCode() : 0); + hash = 73 * hash + (this.domain_ != null ? this.domain_.hashCode() : 0); + hash = 73 * hash + (this.resource_ != null ? this.resource_.hashCode() : 0); + return hash; + } +} diff --git a/src/com/isode/stroke/network/Connection.java b/src/com/isode/stroke/network/Connection.java new file mode 100644 index 0000000..ff4a056 --- /dev/null +++ b/src/com/isode/stroke/network/Connection.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; + +public abstract class Connection { + + public enum Error { + + ReadError, + WriteError + }; + + public Connection() { + } + + public abstract void listen(); + + public abstract void connect(HostAddressPort address); + + public abstract void disconnect(); + + public abstract void write(ByteArray data); + + public abstract HostAddressPort getLocalAddress(); + public final Signal1<Boolean /*error*/> onConnectFinished = new Signal1<Boolean>(); + public final Signal1<Error> onDisconnected = new Signal1<Error>(); + public final Signal1<ByteArray> onDataRead = new Signal1<ByteArray>(); + public final Signal onDataWritten = new Signal(); +} diff --git a/src/com/isode/stroke/network/ConnectionFactory.java b/src/com/isode/stroke/network/ConnectionFactory.java new file mode 100644 index 0000000..6764d24 --- /dev/null +++ b/src/com/isode/stroke/network/ConnectionFactory.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + +public interface ConnectionFactory { + Connection createConnection(); +} diff --git a/src/com/isode/stroke/network/Connector.java b/src/com/isode/stroke/network/Connector.java new file mode 100644 index 0000000..560bf7b --- /dev/null +++ b/src/com/isode/stroke/network/Connector.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.network.DomainNameServiceQuery.Result; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.signals.SignalConnection; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.signals.Slot2; +import java.util.ArrayList; +import java.util.Collection; + +public class Connector { + + public static Connector create(String hostname, DomainNameResolver resolver, ConnectionFactory connectionFactory, TimerFactory timerFactory) { + return new Connector(hostname, resolver, connectionFactory, timerFactory); + } + + public void setTimeoutMilliseconds(int milliseconds) { + timeoutMilliseconds = milliseconds; + } + + public void start() { + assert currentConnection == null; + assert serviceQuery == null; + assert timer == null; + queriedAllServices = false; + serviceQuery = resolver.createServiceQuery("_xmpp-client._tcp." + hostname); + serviceQuery.onResult.connect(new Slot1<Collection<DomainNameServiceQuery.Result>>() { + public void call(Collection<Result> p1) { + handleServiceQueryResult(p1); + } + }); + if (timeoutMilliseconds > 0) { + timer = timerFactory.createTimer(timeoutMilliseconds); + timer.onTick.connect(new Slot() { + public void call() { + handleTimeout(); + } + }); + timer.start(); + } + serviceQuery.run(); + } + + public void stop() { + finish(null); + } + + public final Signal1<Connection> onConnectFinished = new Signal1<Connection>(); + + private Connector(String hostname, DomainNameResolver resolver, ConnectionFactory connectionFactory, TimerFactory timerFactory) { + this.hostname = hostname; + this.resolver = resolver; + this.connectionFactory = connectionFactory; + this.timerFactory = timerFactory; + } + + private void handleServiceQueryResult(Collection<Result> result) { + serviceQueryResults = new ArrayList<Result>(); + serviceQueryResults.addAll(result); + serviceQuery = null; + tryNextServiceOrFallback(); + } + + private void handleAddressQueryResult(Collection<HostAddress> addresses, DomainNameResolveError error) { + //std::cout << "Connector::handleAddressQueryResult(): Start" << std::endl; + addressQuery = null; + if (error != null || addresses.isEmpty()) { + if (!serviceQueryResults.isEmpty()) { + serviceQueryResults.remove(0); + } + tryNextServiceOrFallback(); + } + else { + addressQueryResults = new ArrayList<HostAddress>(); + addressQueryResults.addAll(addresses); + tryNextAddress(); + } + } + + private void queryAddress(String hostname) { + assert addressQuery == null; + addressQuery = resolver.createAddressQuery(hostname); + addressQuery.onResult.connect(new Slot2<Collection<HostAddress>, DomainNameResolveError>() { + public void call(Collection<HostAddress> p1, DomainNameResolveError p2) { + handleAddressQueryResult(p1, p2); + } + }); + addressQuery.run(); + } + + private void tryNextServiceOrFallback() { + if (queriedAllServices) { + //std::cout << "Connector::tryNextServiceOrCallback(): Queried all hosts. Error." << std::endl; + finish(null); + } + else if (serviceQueryResults.isEmpty()) { + //std::cout << "Connector::tryNextHostName(): Falling back on A resolution" << std::endl; + // Fall back on simple address resolving + queriedAllServices = true; + queryAddress(hostname); + } + else { + //std::cout << "Connector::tryNextHostName(): Querying next address" << std::endl; + queryAddress(serviceQueryResults.get(0).hostname); + } + } + + private void tryNextAddress() { + if (addressQueryResults.isEmpty()) { + //std::cout << "Connector::tryNextAddress(): Done trying addresses. Moving on" << std::endl; + // Done trying all addresses. Move on to the next host. + if (!serviceQueryResults.isEmpty()) { + serviceQueryResults.remove(0); + } + tryNextServiceOrFallback(); + } + else { + //std::cout << "Connector::tryNextAddress(): trying next address." << std::endl; + HostAddress address = addressQueryResults.get(0); + addressQueryResults.remove(0); + + int port = 5222; + if (!serviceQueryResults.isEmpty()) { + port = serviceQueryResults.get(0).port; + } + + tryConnect(new HostAddressPort(address, port)); + } + } + + private void tryConnect(HostAddressPort target) { + assert currentConnection == null; + //std::cout << "Connector::tryConnect() " << target.getAddress().toString() << " " << target.getPort() << std::endl; + currentConnection = connectionFactory.createConnection(); + currentConnectionConnectFinishedConnection = currentConnection.onConnectFinished.connect(new Slot1<Boolean>() { + public void call(Boolean p1) { + handleConnectionConnectFinished(p1); + } + }); + + currentConnection.connect(target); + } + + private void handleConnectionConnectFinished(boolean error) { + //std::cout << "Connector::handleConnectionConnectFinished() " << error << std::endl; + currentConnectionConnectFinishedConnection.disconnect(); + if (error) { + currentConnection = null; + if (!addressQueryResults.isEmpty()) { + tryNextAddress(); + } + else { + if (!serviceQueryResults.isEmpty()) { + serviceQueryResults.remove(0); + } + tryNextServiceOrFallback(); + } + } + else { + finish(currentConnection); + } + } + + private void finish(Connection connection) { + if (timer != null) { + timer.stop(); + timer.onTick.disconnectAll(); + timer = null; + } + if (serviceQuery != null) { + serviceQuery.onResult.disconnectAll(); + serviceQuery = null; + } + if (addressQuery != null) { + addressQuery.onResult.disconnectAll(); + addressQuery = null; + } + if (currentConnection != null) { + currentConnectionConnectFinishedConnection.disconnect(); + currentConnection = null; + } + onConnectFinished.emit(connection); + } + + private void handleTimeout() { + finish(null); + } + private String hostname; + private DomainNameResolver resolver; + private ConnectionFactory connectionFactory; + private TimerFactory timerFactory; + private int timeoutMilliseconds = 0; + private Timer timer; + private DomainNameServiceQuery serviceQuery; + private ArrayList<DomainNameServiceQuery.Result> serviceQueryResults; + private DomainNameAddressQuery addressQuery; + private ArrayList<HostAddress> addressQueryResults; + private boolean queriedAllServices = true; + private Connection currentConnection; + private SignalConnection currentConnectionConnectFinishedConnection; +} diff --git a/src/com/isode/stroke/network/DomainNameAddressQuery.java b/src/com/isode/stroke/network/DomainNameAddressQuery.java new file mode 100644 index 0000000..1bc9edf --- /dev/null +++ b/src/com/isode/stroke/network/DomainNameAddressQuery.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.signals.Signal2; +import java.util.Collection; + +public abstract class DomainNameAddressQuery { + public abstract void run(); + + public final Signal2<Collection<HostAddress>, DomainNameResolveError> onResult = new Signal2<Collection<HostAddress>, DomainNameResolveError>(); +} diff --git a/src/com/isode/stroke/network/DomainNameResolveError.java b/src/com/isode/stroke/network/DomainNameResolveError.java new file mode 100644 index 0000000..b470c34 --- /dev/null +++ b/src/com/isode/stroke/network/DomainNameResolveError.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.network; + +public class DomainNameResolveError implements com.isode.stroke.base.Error { + +} diff --git a/src/com/isode/stroke/network/DomainNameResolver.java b/src/com/isode/stroke/network/DomainNameResolver.java new file mode 100644 index 0000000..bbd4e79 --- /dev/null +++ b/src/com/isode/stroke/network/DomainNameResolver.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + + +public abstract class DomainNameResolver { + public abstract DomainNameServiceQuery createServiceQuery(String name); + public abstract DomainNameAddressQuery createAddressQuery(String name); + + protected String getNormalized(String domain) { + return domain; + //FIXME: port idna +// char* output; +// if (idna_to_ascii_8z(domain.getUTF8Data(), &output, 0) == IDNA_SUCCESS) { +// String result(output); +// free(output); +// return result; +// } +// else { +// return domain; +// } + } +} diff --git a/src/com/isode/stroke/network/DomainNameServiceQuery.java b/src/com/isode/stroke/network/DomainNameServiceQuery.java new file mode 100644 index 0000000..ddb94a8 --- /dev/null +++ b/src/com/isode/stroke/network/DomainNameServiceQuery.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.signals.Signal1; +import java.util.Collection; + +public abstract class DomainNameServiceQuery { + + public class Result { + + public Result() { + hostname = ""; + port = -1; + priority = -1; + weight = -1; + } + + public Result(String hostname, int port, int priority, int weight) { + this.hostname = hostname; + this.port = port; + this.priority = priority; + this.weight = weight; + } + public final String hostname; + public final int port; + public final int priority; + public final int weight; + }; + + public class ResultPriorityComparator { + + public boolean compare(DomainNameServiceQuery.Result a, DomainNameServiceQuery.Result b) { + return a.priority < b.priority; + } + }; + + public abstract void run(); + public final Signal1<Collection<Result>> onResult = new Signal1<Collection<Result>>(); +} diff --git a/src/com/isode/stroke/network/HostAddress.java b/src/com/isode/stroke/network/HostAddress.java new file mode 100644 index 0000000..152dc2b --- /dev/null +++ b/src/com/isode/stroke/network/HostAddress.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import java.net.InetAddress; + +public class HostAddress { + + public HostAddress() { + address_ = null; + } + + public HostAddress(InetAddress address) { + address_ = address; + } + /* public HostAddress(const String&); + public HostAddress(const unsigned char* address, int length); + public HostAddress(const boost::asio::ip::address& address);*/ + + @Override + public String toString() { + return address_.getHostAddress(); + } + + @Override + public int hashCode() { + int hash = 5; + hash = 29 * hash + (this.address_ != null ? this.address_.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object other) { + if (other instanceof HostAddress) { + return address_.equals(((HostAddress)other).getInetAddress()); + } + return false; + } + + public boolean isValid() { + return address_ != null; + } + + InetAddress getInetAddress() { + return address_; + } + + private final InetAddress address_; +} diff --git a/src/com/isode/stroke/network/HostAddressPort.java b/src/com/isode/stroke/network/HostAddressPort.java new file mode 100644 index 0000000..01048a3 --- /dev/null +++ b/src/com/isode/stroke/network/HostAddressPort.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +public class HostAddressPort { + + public HostAddressPort(HostAddress address) { + address_ = address; + port_ = -1; + } + + public HostAddressPort(HostAddress address, int port) { + address_ = address; + port_ = port; + } + + /* + public HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint) { + address_ = HostAddress(endpoint.address()); + port_ = endpoint.port(); + }*/ //FIXME + public HostAddress getAddress() { + return address_; + } + + public int getPort() { + return port_; + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof HostAddressPort)) return false; + HostAddressPort o = (HostAddressPort)other; + return getAddress().equals(o.getAddress()) && port_ == o.getPort(); + } + + @Override + public int hashCode() { + int hash = 5; + hash = 17 * hash + (this.address_ != null ? this.address_.hashCode() : 0); + hash = 17 * hash + this.port_; + return hash; + } + + public boolean isValid() { + return address_.isValid() && port_ > 0; + } + private HostAddress address_; + private int port_; +} diff --git a/src/com/isode/stroke/network/JavaConnection.java b/src/com/isode/stroke/network/JavaConnection.java new file mode 100644 index 0000000..e43707c --- /dev/null +++ b/src/com/isode/stroke/network/JavaConnection.java @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.eventloop.Event.Callback; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.eventloop.EventOwner; +import java.io.BufferedReader; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.PrintWriter; +import java.net.Socket; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class JavaConnection extends Connection implements EventOwner { + + private class Worker implements Runnable { + + private final HostAddressPort address_; + private OutputStream write_; + private BufferedReader read_; + private final List<ByteArray> writeBuffer_ = Collections.synchronizedList(new ArrayList<ByteArray>()); + + public Worker(HostAddressPort address) { + address_ = address; + } + + public void run() { + try { + socket_ = new Socket(address_.getAddress().getInetAddress(), address_.getPort()); + write_ = socket_.getOutputStream(); + read_ = new BufferedReader(new InputStreamReader(socket_.getInputStream(), "utf-8")); + } catch (IOException ex) { + handleConnected(true); + return; + } + handleConnected(false); + while (!disconnecting_) { + boolean didWrite = false; + while (!writeBuffer_.isEmpty()) { + didWrite = true; + ByteArray data = writeBuffer_.get(0); + for (byte datum : data.getData()) { + try { + write_.write(datum); + } catch (IOException ex) { + disconnecting_ = true; + handleDisconnected(Error.WriteError); + } + } + writeBuffer_.remove(0); + } + if (didWrite && !disconnecting_) { + try { + write_.flush(); + } catch (IOException ex) { + disconnecting_ = true; + handleDisconnected(Error.WriteError); + } + } + ByteArray data = new ByteArray(); + try { + while (read_.ready()) { + char[] c = new char[1024]; + int i = read_.read(c, 0, c.length); + if (i > 0) { + data.append(new String(c, 0, i)); + } + } + } catch (IOException ex) { + handleDisconnected(Error.ReadError); + return; + } + if (!data.isEmpty()) { + handleDataRead(data); + } + try { + Thread.sleep(100); + } catch (InterruptedException ex) { + /* We've been woken up, probably to force us to do something.*/ + } + } + try { + read_.close(); + write_.close(); + socket_.close(); + } catch (IOException ex) { + /* Do we need to return an error if we're already trying to close? */ + } + } + + private void handleConnected(final boolean error) { + eventLoop_.postEvent(new Callback() { + public void run() { + onConnectFinished.emit(error); + } + }); + } + + private void handleDisconnected(final Error error) { + eventLoop_.postEvent(new Callback() { + public void run() { + onDisconnected.emit(error); + } + }); + } + + private void handleDataRead(final ByteArray data) { + eventLoop_.postEvent(new Callback() { + public void run() { + onDataRead.emit(data); + } + }); + } + + public void write(ByteArray data) { + writeBuffer_.add(data); + } + } + + private JavaConnection(EventLoop eventLoop) { + eventLoop_ = eventLoop; + } + + public static JavaConnection create(EventLoop eventLoop) { + return new JavaConnection(eventLoop); + } + + @Override + public void listen() { + //TODO: needed for server, not for client. + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void connect(HostAddressPort address) { + worker_ = new Worker(address); + Thread workerThread = new Thread(worker_); + workerThread.setDaemon(true); + workerThread.start(); + } + + @Override + public void disconnect() { + disconnecting_ = true; + } + + @Override + public void write(ByteArray data) { + worker_.writeBuffer_.add(data); + } + + @Override + public HostAddressPort getLocalAddress() { + return new HostAddressPort(new HostAddress(socket_.getLocalAddress()), socket_.getLocalPort()); + } + private final EventLoop eventLoop_; + private boolean disconnecting_ = false; + private Socket socket_; + private Worker worker_; +} diff --git a/src/com/isode/stroke/network/JavaConnectionFactory.java b/src/com/isode/stroke/network/JavaConnectionFactory.java new file mode 100644 index 0000000..956e80b --- /dev/null +++ b/src/com/isode/stroke/network/JavaConnectionFactory.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.EventLoop; + +public class JavaConnectionFactory implements ConnectionFactory { + + public JavaConnectionFactory(EventLoop eventLoop) { + this.eventLoop = eventLoop; + } + + public Connection createConnection() { + return JavaConnection.create(eventLoop); + } + + private final EventLoop eventLoop; +} diff --git a/src/com/isode/stroke/network/JavaNetworkFactories.java b/src/com/isode/stroke/network/JavaNetworkFactories.java new file mode 100644 index 0000000..acd289b --- /dev/null +++ b/src/com/isode/stroke/network/JavaNetworkFactories.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.EventLoop; + +public class JavaNetworkFactories implements NetworkFactories { + + public JavaNetworkFactories(EventLoop eventLoop) { + eventLoop_ = eventLoop; + timers_ = new JavaTimerFactory(eventLoop_); + connections_ = new JavaConnectionFactory(eventLoop_); + dns_ = new PlatformDomainNameResolver(eventLoop_); + } + + public TimerFactory getTimerFactory() { + return timers_; + } + + public ConnectionFactory getConnectionFactory() { + return connections_; + } + + public DomainNameResolver getDomainNameResolver() { + return dns_; + } + private final EventLoop eventLoop_; + private final JavaTimerFactory timers_; + private final JavaConnectionFactory connections_; + private final PlatformDomainNameResolver dns_; +} diff --git a/src/com/isode/stroke/network/JavaTimer.java b/src/com/isode/stroke/network/JavaTimer.java new file mode 100644 index 0000000..61357d4 --- /dev/null +++ b/src/com/isode/stroke/network/JavaTimer.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.Event; +import com.isode.stroke.eventloop.EventLoop; + +class JavaTimer extends Timer { + + private class TimerRunnable implements Runnable { + + boolean running_ = true; + private final EventLoop eventLoop_; + private final int milliseconds_; + + public TimerRunnable(EventLoop eventLoop, int milliseconds) { + eventLoop_ = eventLoop; + milliseconds_ = milliseconds; + } + + public void run() { + while (shouldEmit()) { + try { + Thread.sleep(milliseconds_); + } catch (InterruptedException ex) { + /* If we were interrupted, either emit or don't, based on whether stop was called.*/ + } + if (shouldEmit()) { + eventLoop_.postEvent(new Event.Callback() { + public void run() { + onTick.emit(); + } + }); + } + } + } + + + synchronized boolean shouldEmit() { + return running_; + } + + public synchronized void stop() { + running_ = false; + } + } + + public JavaTimer(EventLoop eventLoop, int milliseconds) { + timer_ = new TimerRunnable(eventLoop, milliseconds); + } + + @Override + public void start() { + Thread thread = (new Thread(timer_)); + thread.setDaemon(true); + thread.start(); + } + + @Override + public void stop() { + timer_.stop(); + //FIXME: This needs to clear any remaining events out of the EventLoop queue. + } + private final TimerRunnable timer_; +} diff --git a/src/com/isode/stroke/network/JavaTimerFactory.java b/src/com/isode/stroke/network/JavaTimerFactory.java new file mode 100644 index 0000000..10017a8 --- /dev/null +++ b/src/com/isode/stroke/network/JavaTimerFactory.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.EventLoop; + +public class JavaTimerFactory implements TimerFactory { + + public JavaTimerFactory(EventLoop eventLoop) { + eventLoop_ = eventLoop; + } + + public Timer createTimer(int milliseconds) { + return new JavaTimer(eventLoop_, milliseconds); + } + + private final EventLoop eventLoop_; + +} diff --git a/src/com/isode/stroke/network/NetworkFactories.java b/src/com/isode/stroke/network/NetworkFactories.java new file mode 100644 index 0000000..b630b85 --- /dev/null +++ b/src/com/isode/stroke/network/NetworkFactories.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.network; + +public interface NetworkFactories { + + TimerFactory getTimerFactory(); + ConnectionFactory getConnectionFactory(); + DomainNameResolver getDomainNameResolver(); + +} diff --git a/src/com/isode/stroke/network/PlatformDomainNameResolver.java b/src/com/isode/stroke/network/PlatformDomainNameResolver.java new file mode 100644 index 0000000..50d0e11 --- /dev/null +++ b/src/com/isode/stroke/network/PlatformDomainNameResolver.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.eventloop.EventOwner; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Collection; + + +public class PlatformDomainNameResolver extends DomainNameResolver { + + private class AddressQuery extends DomainNameAddressQuery implements EventOwner { + AddressQuery(String host, EventLoop eventLoop) { + hostname = host; + this.eventLoop = eventLoop; + //FIXME: port asyncDNS +// thread = null; +// safeToJoin = false; + } + + public void run() { + //FIXME: port asyncDNS + Collection<HostAddress> results = new ArrayList<HostAddress>(); + try { + results.add(new HostAddress(InetAddress.getByName(hostname))); + } catch (UnknownHostException ex) { + + } + onResult.emit(results, results.isEmpty() ? new DomainNameResolveError() : null); + +// safeToJoin = false; +// thread = new boost::thread(boost::bind(&AddressQuery::doRun, shared_from_this())); + } +// FIXME: Port async DNS. +// void doRun() { +// //std::cout << "PlatformDomainNameResolver::doRun()" << std::endl; +// boost::asio::ip::tcp::resolver resolver(ioService); +// boost::asio::ip::tcp::resolver::query query(hostname.getUTF8String(), "5222"); +// try { +// //std::cout << "PlatformDomainNameResolver::doRun(): Resolving" << std::endl; +// boost::asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve(query); +// //std::cout << "PlatformDomainNameResolver::doRun(): Resolved" << std::endl; +// if (endpointIterator == boost::asio::ip::tcp::resolver::iterator()) { +// //std::cout << "PlatformDomainNameResolver::doRun(): Error 1" << std::endl; +// emitError(); +// } +// else { +// std::vector<HostAddress> results; +// for ( ; endpointIterator != boost::asio::ip::tcp::resolver::iterator(); ++endpointIterator) { +// boost::asio::ip::address address = (*endpointIterator).endpoint().address(); +// results.push_back(address.is_v4() ? HostAddress(&address.to_v4().to_bytes()[0], 4) : HostAddress(&address.to_v6().to_bytes()[0], 16)); +// } +// +// //std::cout << "PlatformDomainNameResolver::doRun(): Success" << std::endl; +// eventLoop->postEvent( +// boost::bind(boost::ref(onResult), results, boost::optional<DomainNameResolveError>()), +// shared_from_this()); +// } +// } +// catch (...) { +// //std::cout << "PlatformDomainNameResolver::doRun(): Error 2" << std::endl; +// emitError(); +// } +// safeToJoin = true; +// } +// +// void emitError() { +// eventLoop->postEvent(boost::bind(boost::ref(onResult), std::vector<HostAddress>(), boost::optional<DomainNameResolveError>(DomainNameResolveError())), shared_from_this()); +// } +// +// boost::asio::io_service ioService; + String hostname; + EventLoop eventLoop; +// boost::thread* thread; +// bool safeToJoin; + } + + public PlatformDomainNameResolver(EventLoop eventLoop) { + this.eventLoop = eventLoop; + } + + @Override + public DomainNameServiceQuery createServiceQuery(String name) { + return new PlatformDomainNameServiceQuery(getNormalized(name), eventLoop); + } + + @Override + public DomainNameAddressQuery createAddressQuery(String name) { + return new AddressQuery(getNormalized(name), eventLoop); + } + + private final EventLoop eventLoop; +} diff --git a/src/com/isode/stroke/network/PlatformDomainNameServiceQuery.java b/src/com/isode/stroke/network/PlatformDomainNameServiceQuery.java new file mode 100644 index 0000000..5c94e4d --- /dev/null +++ b/src/com/isode/stroke/network/PlatformDomainNameServiceQuery.java @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.eventloop.EventOwner; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Hashtable; +import javax.naming.NamingException; +import javax.naming.directory.Attribute; +import javax.naming.directory.Attributes; +import javax.naming.directory.DirContext; +import javax.naming.directory.InitialDirContext; + + +public class PlatformDomainNameServiceQuery extends DomainNameServiceQuery implements EventOwner { + + public PlatformDomainNameServiceQuery(String service, EventLoop eventLoop) { + this.service = service; + this.eventLoop = eventLoop; + } + + @Override + public void run() { + //TODO: Make async + Collection<Result> results = new ArrayList<Result>(); + Hashtable env = new Hashtable(); + env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory"); + env.put("java.naming.provider.url", "dns:"); + try { + DirContext ctx = new InitialDirContext(env); + Attributes attrs = ctx.getAttributes(this.service, new String[]{"SRV"}); + Attribute attribute = attrs.get("SRV"); + for (int i = 0; attribute != null && i < attribute.size(); i++) { + /* SRV results are going to be returned in the space-separated format + * Priority Weight Port Target + * (See RFC2782) + */ + String[] srvParts = ((String) attribute.get(i)).split(" "); + String host = srvParts[3]; + if (host.endsWith(".")) { + host = host.substring(0, host.length() - 1); + } + Result result = new Result(host, Integer.parseInt(srvParts[2]), Integer.parseInt(srvParts[0]), Integer.parseInt(srvParts[1])); + results.add(result); + } + } catch (NamingException ex) { + /* Turns out that you get the exception just for not finding a result, so we want to fall through to A lookups and ignore.*/ + } + + onResult.emit(results); + } + + +// void PlatformDomainNameServiceQuery::doRun() { +// std::vector<DomainNameServiceQuery::Result> records; +// +//#if defined(SWIFTEN_PLATFORM_WINDOWS) +// DNS_RECORD* responses; +// // FIXME: This conversion doesn't work if unicode is deffed above +// if (DnsQuery(service.getUTF8Data(), DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &responses, NULL) != ERROR_SUCCESS) { +// emitError(); +// return; +// } +// +// DNS_RECORD* currentEntry = responses; +// while (currentEntry) { +// if (currentEntry->wType == DNS_TYPE_SRV) { +// DomainNameServiceQuery::Result record; +// record.priority = currentEntry->Data.SRV.wPriority; +// record.weight = currentEntry->Data.SRV.wWeight; +// record.port = currentEntry->Data.SRV.wPort; +// +// // The pNameTarget is actually a PCWSTR, so I would have expected this +// // conversion to not work at all, but it does. +// // Actually, it doesn't. Fix this and remove explicit cast +// // Remove unicode undef above as well +// record.hostname = String((const char*) currentEntry->Data.SRV.pNameTarget); +// records.push_back(record); +// } +// currentEntry = currentEntry->pNext; +// } +// DnsRecordListFree(responses, DnsFreeRecordList); +// +//#else +// // Make sure we reinitialize the domain list every time +// res_init(); +// +// //std::cout << "SRV: Querying " << service << std::endl; +// ByteArray response; +// response.resize(NS_PACKETSZ); +// int responseLength = res_query(const_cast<char*>(service.getUTF8Data()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(response.getData()), response.getSize()); +// if (responseLength == -1) { +// emitError(); +// return; +// } +// +// // Parse header +// HEADER* header = reinterpret_cast<HEADER*>(response.getData()); +// unsigned char* messageStart = reinterpret_cast<unsigned char*>(response.getData()); +// unsigned char* messageEnd = messageStart + responseLength; +// unsigned char* currentEntry = messageStart + NS_HFIXEDSZ; +// +// // Skip over the queries +// int queriesCount = ntohs(header->qdcount); +// while (queriesCount > 0) { +// int entryLength = dn_skipname(currentEntry, messageEnd); +// if (entryLength < 0) { +// emitError(); +// return; +// } +// currentEntry += entryLength + NS_QFIXEDSZ; +// queriesCount--; +// } +// +// // Process the SRV answers +// int answersCount = ntohs(header->ancount); +// while (answersCount > 0) { +// DomainNameServiceQuery::Result record; +// +// int entryLength = dn_skipname(currentEntry, messageEnd); +// currentEntry += entryLength; +// currentEntry += NS_RRFIXEDSZ; +// +// // Priority +// if (currentEntry + 2 >= messageEnd) { +// emitError(); +// return; +// } +// record.priority = ns_get16(currentEntry); +// currentEntry += 2; +// +// // Weight +// if (currentEntry + 2 >= messageEnd) { +// emitError(); +// return; +// } +// record.weight = ns_get16(currentEntry); +// currentEntry += 2; +// +// // Port +// if (currentEntry + 2 >= messageEnd) { +// emitError(); +// return; +// } +// record.port = ns_get16(currentEntry); +// currentEntry += 2; +// +// // Hostname +// if (currentEntry >= messageEnd) { +// emitError(); +// return; +// } +// ByteArray entry; +// entry.resize(NS_MAXDNAME); +// entryLength = dn_expand(messageStart, messageEnd, currentEntry, entry.getData(), entry.getSize()); +// if (entryLength < 0) { +// emitError(); +// return; +// } +// record.hostname = String(entry.getData()); +// records.push_back(record); +// currentEntry += entryLength; +// answersCount--; +// } +//#endif +// +// safeToJoin = true; +// std::sort(records.begin(), records.end(), ResultPriorityComparator()); +// //std::cout << "Sending out " << records.size() << " SRV results " << std::endl; +// eventLoop->postEvent(boost::bind(boost::ref(onResult), records)); +//} + + + private final String service; + private final EventLoop eventLoop; +} diff --git a/src/com/isode/stroke/network/Timer.java b/src/com/isode/stroke/network/Timer.java new file mode 100644 index 0000000..5dc3854 --- /dev/null +++ b/src/com/isode/stroke/network/Timer.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + +import com.isode.stroke.signals.Signal; + +public abstract class Timer { + public abstract void start(); + public abstract void stop(); + public final Signal onTick = new Signal(); +} diff --git a/src/com/isode/stroke/network/TimerFactory.java b/src/com/isode/stroke/network/TimerFactory.java new file mode 100644 index 0000000..2732aaf --- /dev/null +++ b/src/com/isode/stroke/network/TimerFactory.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.network; + + +public interface TimerFactory { + Timer createTimer(int milliseconds); +} diff --git a/src/com/isode/stroke/parser/AttributeMap.java b/src/com/isode/stroke/parser/AttributeMap.java new file mode 100644 index 0000000..dc948ce --- /dev/null +++ b/src/com/isode/stroke/parser/AttributeMap.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import java.util.HashMap; + +/** + * XML element attributes. + */ +public class AttributeMap extends HashMap<String, String> { + public String getAttribute(String attribute) { + return this.get(attribute); + } + + public String getAttributeValue(String attribute) { + return this.containsKey(attribute) ? this.get(attribute) : null; + } + + public boolean getBoolAttribute(String attribute) { + return getBoolAttribute(attribute, false); + } + + public boolean getBoolAttribute(String attribute, boolean defaultValue) { + String value = getAttribute(attribute); + return "true".equals(value) || "1".equals(value); + } +} diff --git a/src/com/isode/stroke/parser/AuthChallengeParser.java b/src/com/isode/stroke/parser/AuthChallengeParser.java new file mode 100644 index 0000000..20238dd --- /dev/null +++ b/src/com/isode/stroke/parser/AuthChallengeParser.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.AuthChallenge; +import com.isode.stroke.stringcodecs.Base64; + +class AuthChallengeParser extends GenericElementParser<AuthChallenge> { + + public AuthChallengeParser() { + super(AuthChallenge.class); + } + + @Override + public void handleStartElement(String unused1, String unused2, AttributeMap unused3) { + ++depth; + } + + @Override + public void handleEndElement(String unused1, String unused2) { + --depth; + if (depth == 0) { + getElementGeneric().setValue(Base64.decode(text)); + } + } + + @Override + public void handleCharacterData(String text) { + this.text += text; + } + private int depth = 0; + private String text = ""; +} diff --git a/src/com/isode/stroke/parser/AuthFailureParser.java b/src/com/isode/stroke/parser/AuthFailureParser.java new file mode 100644 index 0000000..c42abed --- /dev/null +++ b/src/com/isode/stroke/parser/AuthFailureParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.AuthFailure; + +class AuthFailureParser extends GenericElementParser<AuthFailure> { + + public AuthFailureParser() { + super(AuthFailure.class); + } + +} diff --git a/src/com/isode/stroke/parser/AuthRequestParser.java b/src/com/isode/stroke/parser/AuthRequestParser.java new file mode 100644 index 0000000..7f40c9c --- /dev/null +++ b/src/com/isode/stroke/parser/AuthRequestParser.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.AuthRequest; +import com.isode.stroke.stringcodecs.Base64; + +class AuthRequestParser extends GenericElementParser<AuthRequest> { + + public AuthRequestParser() { + super(AuthRequest.class); + } + + @Override + public void handleStartElement(String a, String b, AttributeMap attribute) { + if (depth_ == 0) { + getElementGeneric().setMechanism(attribute.getAttribute("mechanism")); + } + ++depth_; + } + + @Override + public void handleEndElement(String a, String b) { + --depth_; + if (depth_ == 0) { + getElementGeneric().setMessage(Base64.decode(text_)); + } + } + + @Override + public void handleCharacterData(String a) { + text_ += a; + } + String text_ = ""; + int depth_ = 0; +} diff --git a/src/com/isode/stroke/parser/AuthResponseParser.java b/src/com/isode/stroke/parser/AuthResponseParser.java new file mode 100644 index 0000000..a93249a --- /dev/null +++ b/src/com/isode/stroke/parser/AuthResponseParser.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.AuthResponse; +import com.isode.stroke.stringcodecs.Base64; + +class AuthResponseParser extends GenericElementParser<AuthResponse> { + + public AuthResponseParser() { + super(AuthResponse.class); + } + + @Override + public void handleStartElement(String unused1, String unused2, AttributeMap unused3) { + ++depth; + } + + @Override + public void handleEndElement(String unused1, String unused2) { + --depth; + if (depth == 0) { + getElementGeneric().setValue(Base64.decode(text)); + } + } + + @Override + public void handleCharacterData(String text) { + this.text += text; + } + private int depth = 0; + private String text = ""; +} diff --git a/src/com/isode/stroke/parser/AuthSuccessParser.java b/src/com/isode/stroke/parser/AuthSuccessParser.java new file mode 100644 index 0000000..111d3ce --- /dev/null +++ b/src/com/isode/stroke/parser/AuthSuccessParser.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.AuthSuccess; +import com.isode.stroke.stringcodecs.Base64; + +class AuthSuccessParser extends GenericElementParser<AuthSuccess> { + + public AuthSuccessParser() { + super(AuthSuccess.class); + } + + @Override + public void handleStartElement(String a, String b, AttributeMap attribute) { + ++depth_; + } + + @Override + public void handleEndElement(String a, String b) { + --depth_; + if (depth_ == 0) { + getElementGeneric().setValue(Base64.decode(text_)); + } + } + + @Override + public void handleCharacterData(String a) { + text_ += a; + } + String text_ = ""; + int depth_ = 0; +} diff --git a/src/com/isode/stroke/parser/CompressFailureParser.java b/src/com/isode/stroke/parser/CompressFailureParser.java new file mode 100644 index 0000000..cbfa413 --- /dev/null +++ b/src/com/isode/stroke/parser/CompressFailureParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.CompressFailure; + +class CompressFailureParser extends GenericElementParser<CompressFailure> { + + public CompressFailureParser() { + super(CompressFailure.class); + } + +} diff --git a/src/com/isode/stroke/parser/CompressParser.java b/src/com/isode/stroke/parser/CompressParser.java new file mode 100644 index 0000000..133b20b --- /dev/null +++ b/src/com/isode/stroke/parser/CompressParser.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.CompressRequest; + +class CompressParser extends GenericElementParser<CompressRequest> { + + private int currentDepth_ = 0; + private String currentText_; + private boolean inMethod_; + + public CompressParser() { + super(CompressRequest.class); + } + + @Override + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (currentDepth_ == 1 && element.equals("method")) { + inMethod_ = true; + currentText_ = ""; + } + ++currentDepth_; + } + + @Override + public void handleEndElement(String el, String ns) { + --currentDepth_; + if (currentDepth_ == 1 && inMethod_) { + getElementGeneric().setMethod(currentText_); + inMethod_ = false; + } + } + + @Override + public void handleCharacterData(String data) { + currentText_ += data; + } +} diff --git a/src/com/isode/stroke/parser/CompressedParser.java b/src/com/isode/stroke/parser/CompressedParser.java new file mode 100644 index 0000000..77d17e4 --- /dev/null +++ b/src/com/isode/stroke/parser/CompressedParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Compressed; + +class CompressedParser extends GenericElementParser<Compressed> { + + public CompressedParser() { + super(Compressed.class); + } + +} diff --git a/src/com/isode/stroke/parser/ElementParser.java b/src/com/isode/stroke/parser/ElementParser.java new file mode 100644 index 0000000..eebb51a --- /dev/null +++ b/src/com/isode/stroke/parser/ElementParser.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Element; + +/** + * Parse XML Elements. + */ +public interface ElementParser { + + void handleStartElement(String element, String ns, AttributeMap attributes); + + void handleEndElement(String element, String ns); + + void handleCharacterData(String data); + + Element getElement(); +} diff --git a/src/com/isode/stroke/parser/EnableStreamManagementParser.java b/src/com/isode/stroke/parser/EnableStreamManagementParser.java new file mode 100644 index 0000000..fe657dd --- /dev/null +++ b/src/com/isode/stroke/parser/EnableStreamManagementParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.EnableStreamManagement; + +class EnableStreamManagementParser extends GenericElementParser<EnableStreamManagement> { + + public EnableStreamManagementParser() { + super(EnableStreamManagement.class); + } + +} diff --git a/src/com/isode/stroke/parser/GenericElementParser.java b/src/com/isode/stroke/parser/GenericElementParser.java new file mode 100644 index 0000000..da961f6 --- /dev/null +++ b/src/com/isode/stroke/parser/GenericElementParser.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Element; + +public class GenericElementParser<T extends Element> implements ElementParser { + + private final T element_; + + public GenericElementParser(Class c) { + try { + element_ = (T) c.newInstance(); + } catch (InstantiationException ex) { + /* Fatal */ + throw new RuntimeException(ex); + } catch (IllegalAccessException ex) { + /* Fatal */ + throw new RuntimeException(ex); + } + } + + + public Element getElement() { + return element_; + } + + protected T getElementGeneric() { + return element_; + } + + public void handleStartElement(String a, String b, AttributeMap c) { + } + + public void handleEndElement(String a, String b) { + } + + public void handleCharacterData(String a) { + } +} diff --git a/src/com/isode/stroke/parser/GenericPayloadParser.java b/src/com/isode/stroke/parser/GenericPayloadParser.java new file mode 100644 index 0000000..7ac8337 --- /dev/null +++ b/src/com/isode/stroke/parser/GenericPayloadParser.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Payload; + +public abstract class GenericPayloadParser <T extends Payload> implements PayloadParser { + private T payload_; + + public GenericPayloadParser(T payload) { + payload_ = payload; + } + + public Payload getPayload() { + return payload_; + } + + protected T getPayloadInternal() { + return payload_; + } +} diff --git a/src/com/isode/stroke/parser/GenericPayloadParserFactory.java b/src/com/isode/stroke/parser/GenericPayloadParserFactory.java new file mode 100644 index 0000000..a6d7e25 --- /dev/null +++ b/src/com/isode/stroke/parser/GenericPayloadParserFactory.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +public class GenericPayloadParserFactory<T extends PayloadParser> implements PayloadParserFactory { + + private final String tag_; + private final String xmlns_; + private final Class payloadClass_; + + public GenericPayloadParserFactory(final String tag, final Class<? extends PayloadParser> payloadClass) { + this(tag, "", payloadClass); + } + + public GenericPayloadParserFactory(final String tag, final String xmlns, final Class<? extends PayloadParser> payloadClass) { + tag_ = tag; + xmlns_ = xmlns; + payloadClass_ = payloadClass; + } + + public boolean canParse(final String element, final String ns, final AttributeMap attributes) { + return element.equals(tag_) && xmlns_.equals(ns); + } + + public final PayloadParser createPayloadParser() { + try { + return (PayloadParser) payloadClass_.newInstance(); + } catch (InstantiationException ex) { + /* Fatal */ + throw new RuntimeException(ex); + } catch (IllegalAccessException ex) { + /* Fatal */ + throw new RuntimeException(ex); + } + } +} diff --git a/src/com/isode/stroke/parser/GenericStanzaParser.java b/src/com/isode/stroke/parser/GenericStanzaParser.java new file mode 100644 index 0000000..0f3c6c1 --- /dev/null +++ b/src/com/isode/stroke/parser/GenericStanzaParser.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.Stanza; + +public class GenericStanzaParser<T extends Stanza> extends StanzaParser { + private final T stanza_; + public GenericStanzaParser(PayloadParserFactoryCollection collection, T blankStanza) { + super(collection); + stanza_ = blankStanza; + } + + public Element getElement() { + return stanza_; + } + + public T getStanzaGeneric() { + return stanza_; + } +} diff --git a/src/com/isode/stroke/parser/IQParser.java b/src/com/isode/stroke/parser/IQParser.java new file mode 100644 index 0000000..3e8325a --- /dev/null +++ b/src/com/isode/stroke/parser/IQParser.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.IQ; + +public class IQParser extends GenericStanzaParser<IQ> { + + public IQParser(PayloadParserFactoryCollection factories) { + super(factories, new IQ()); + } + + @Override + void handleStanzaAttributes(AttributeMap attributes) { + String type = attributes.getAttribute("type"); + if ("set".equals(type)) { + getStanzaGeneric().setType(IQ.Type.Set); + } else if ("get".equals(type)) { + getStanzaGeneric().setType(IQ.Type.Get); + } else if ("result".equals(type)) { + getStanzaGeneric().setType(IQ.Type.Result); + } else if ("error".equals(type)) { + getStanzaGeneric().setType(IQ.Type.Error); + } else { + getStanzaGeneric().setType(IQ.Type.Get); + } + } +} diff --git a/src/com/isode/stroke/parser/MessageParser.java b/src/com/isode/stroke/parser/MessageParser.java new file mode 100644 index 0000000..1294e62 --- /dev/null +++ b/src/com/isode/stroke/parser/MessageParser.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Message; + +public class MessageParser extends GenericStanzaParser<Message> { + + public MessageParser(PayloadParserFactoryCollection factories) { + super(factories, new Message()); + } + + @Override + void handleStanzaAttributes(AttributeMap attributes) { + String type = attributes.getAttribute("type"); + if ("chat".equals(type)) { + getStanzaGeneric().setType(Message.Type.Chat); + } else if ("error".equals(type)) { + getStanzaGeneric().setType(Message.Type.Error); + } else if ("groupchat".equals(type)) { + getStanzaGeneric().setType(Message.Type.Groupchat); + } else if ("headline".equals(type)) { + getStanzaGeneric().setType(Message.Type.Headline); + } else { + getStanzaGeneric().setType(Message.Type.Normal); + } + } +} diff --git a/src/com/isode/stroke/parser/PayloadParser.java b/src/com/isode/stroke/parser/PayloadParser.java new file mode 100644 index 0000000..c0dfb43 --- /dev/null +++ b/src/com/isode/stroke/parser/PayloadParser.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Payload; + +/** + * Parse a payload. + */ +public interface PayloadParser { + + void handleStartElement(String element, String ns, AttributeMap attributes); + + void handleEndElement(String element, String ns); + + void handleCharacterData(String data); + + Payload getPayload(); +} diff --git a/src/com/isode/stroke/parser/PayloadParserFactory.java b/src/com/isode/stroke/parser/PayloadParserFactory.java new file mode 100644 index 0000000..3b07395 --- /dev/null +++ b/src/com/isode/stroke/parser/PayloadParserFactory.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +/** + * Create a parser. + */ +public interface PayloadParserFactory { + boolean canParse(String element, String ns, AttributeMap attributes); + PayloadParser createPayloadParser(); +} diff --git a/src/com/isode/stroke/parser/PayloadParserFactoryCollection.java b/src/com/isode/stroke/parser/PayloadParserFactoryCollection.java new file mode 100644 index 0000000..2d3601b --- /dev/null +++ b/src/com/isode/stroke/parser/PayloadParserFactoryCollection.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import java.util.Vector; + +/** + * Collection of parser factories. + */ +public class PayloadParserFactoryCollection { + + private final Vector<PayloadParserFactory> factories_ = new Vector<PayloadParserFactory>(); + private PayloadParserFactory defaultFactory_ = null; + + public void addFactory(PayloadParserFactory factory) { + synchronized (factories_) { + factories_.add(factory); + } + } + + public void setDefaultFactory(PayloadParserFactory factory) { + defaultFactory_ = factory; + } + + public PayloadParserFactory getPayloadParserFactory(String element, String ns, AttributeMap attributes) { + synchronized(factories_) { + for (PayloadParserFactory factory : factories_) { + if (factory.canParse(element, ns, attributes)) { + return factory; + } + } + } + return defaultFactory_; + } +} diff --git a/src/com/isode/stroke/parser/PlatformXMLParserFactory.java b/src/com/isode/stroke/parser/PlatformXMLParserFactory.java new file mode 100644 index 0000000..85c9ae9 --- /dev/null +++ b/src/com/isode/stroke/parser/PlatformXMLParserFactory.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.eventloop.EventLoop; + +class PlatformXMLParserFactory { + /** + * Unlike Swiften, this may be threaded, and therefore needs an eventloop. + */ + public static XMLParser createXMLParser(XMLParserClient client, EventLoop eventLoop) { + return new PullXMLParser(client, eventLoop); + } +} diff --git a/src/com/isode/stroke/parser/PresenceParser.java b/src/com/isode/stroke/parser/PresenceParser.java new file mode 100644 index 0000000..cca8729 --- /dev/null +++ b/src/com/isode/stroke/parser/PresenceParser.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Presence; + +public class PresenceParser extends GenericStanzaParser<Presence> { + + public PresenceParser(PayloadParserFactoryCollection factories) { + super(factories, new Presence()); + } + + @Override + void handleStanzaAttributes(AttributeMap attributes) { + String type = attributes.getAttribute("type"); + if (type != null) { + if (type.equals("unavailable")) { + getStanzaGeneric().setType(Presence.Type.Unavailable); + } else if (type.equals("probe")) { + getStanzaGeneric().setType(Presence.Type.Probe); + } else if (type.equals("subscribe")) { + getStanzaGeneric().setType(Presence.Type.Subscribe); + } else if (type.equals("subscribed")) { + getStanzaGeneric().setType(Presence.Type.Subscribed); + } else if (type.equals("unsubscribe")) { + getStanzaGeneric().setType(Presence.Type.Unsubscribe); + } else if (type.equals("unsubscribed")) { + getStanzaGeneric().setType(Presence.Type.Unsubscribed); + } else if (type.equals("error")) { + getStanzaGeneric().setType(Presence.Type.Error); + } else { + getStanzaGeneric().setType(Presence.Type.Available); + } + } else { + getStanzaGeneric().setType(Presence.Type.Available); + } + } +} diff --git a/src/com/isode/stroke/parser/PullXMLParser.java b/src/com/isode/stroke/parser/PullXMLParser.java new file mode 100644 index 0000000..8b42afe --- /dev/null +++ b/src/com/isode/stroke/parser/PullXMLParser.java @@ -0,0 +1,219 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.eventloop.Event.Callback; +import com.isode.stroke.eventloop.EventLoop; +import java.io.IOException; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.xmlpull.mxp1.MXParser; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +/** + * Parser based around the XmlPullParser + */ +class PullXMLParser extends XMLParser { + + private final Logger logger_ = Logger.getLogger(this.getClass().getName()); + private final XmlPullParser parser_ = new MXParser(); + private final PipedInputStream reader_; + private final PipedOutputStream writer_; + private final ArrayBlockingQueue<Event> events_ = new ArrayBlockingQueue<Event>(20); + private final Thread parserThread_; + private boolean error_ = false; + private final EventLoop eventLoop_; + + + private enum EventType {Start, End, Text}; + + /** + * XML Event struct. + */ + private class Event { + private final EventType type; + private final String name; + private final String namespace; + private final AttributeMap attributes; + public Event(EventType type, String name, String namespace, AttributeMap attributes) { + this.type = type; + this.name = name; + this.namespace = namespace; + this.attributes = attributes; + } + + public Event(String name) { + this(EventType.Text, name, null, null); + } + + + public Event(String name, String namespace) { + this(EventType.End, name, namespace, null); + } + + public Event(String name, String namespace, AttributeMap attributes) { + this(EventType.Start, name, namespace, attributes); + } + + } + + /** + * Put an XML event onto the queue ready for the main thread to pick up later. + */ + private void addEvent(Event event) throws InterruptedException { + events_.put(event); + } + + /** + * Deal with whatever was just read out of the parser_. + */ + private void handleEvent(int eventType) throws XmlPullParserException, InterruptedException { + if (eventType == XmlPullParser.START_TAG) { + AttributeMap map = new AttributeMap(); + for (int i = 0; i < parser_.getAttributeCount(); i++) { + map.put(parser_.getAttributeName(i), parser_.getAttributeValue(i)); + } + addEvent(new Event(parser_.getName(), parser_.getNamespace(), map)); + bump(); + } else if (eventType == XmlPullParser.END_TAG) { + addEvent(new Event(parser_.getName(), parser_.getNamespace())); + bump(); + } else if (eventType == XmlPullParser.TEXT) { + StringBuilder text = new StringBuilder(); + int holderForStartAndLength[] = new int[2]; + char ch[] = parser_.getTextCharacters(holderForStartAndLength); + int start = holderForStartAndLength[0]; + int length = holderForStartAndLength[1]; + for (int i = start; i < start + length; i++) { + text.append(ch[i]); + } + addEvent(new Event(text.toString())); + bump(); + } else if (eventType == XmlPullParser.START_DOCUMENT) { + //System.out.println("Starting document"); + } else if (eventType == XmlPullParser.END_DOCUMENT) { + //System.out.println("Ending document"); + + } else { + //System.out.println("Unhandled event"); + } + } + + /** + * Cause the main thread to process any outstanding events. + */ + private void bump() { + eventLoop_.postEvent(new Callback() { + public void run() { + processEvents(); + } + }); + } + + public PullXMLParser(XMLParserClient client, EventLoop eventLoop) { + super(client); + eventLoop_ = eventLoop; + writer_ = new PipedOutputStream(); + try { + reader_ = new PipedInputStream(writer_, 128000); + } catch (IOException ex) { + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + throw new IllegalStateException(ex); + } + try { + parser_.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + parser_.setInput(reader_, "UTF-8"); + } catch (XmlPullParserException ex) { + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + throw new IllegalStateException(ex); + } + Runnable parserRunnable = new Runnable() { + public void run() { + int eventType = XmlPullParser.END_DOCUMENT - 1; /* Anything to make the following not true*/ + while (eventType != XmlPullParser.END_DOCUMENT) { + try { + parser_.next(); + eventType = parser_.getEventType(); + handleEvent(eventType); + } catch (XmlPullParserException ex) { + error_ = true; + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + break; + } catch (IOException ex) { + error_ = true; + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + break; + } catch (InterruptedException ex) { + /* The thread was interrupted while trying to process an event - presumably this is because we're shutting down.*/ + error_ = true; + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + break; + } + } + } + }; + parserThread_ = new Thread(parserRunnable); + parserThread_.setDaemon(true); + parserThread_.start(); + } + + /** + * Do not do this! + * This is only to allow the unit tests to join onto it. + * @return + */ + Thread getParserThread() { + return parserThread_; + } + + /** + * Process outstanding events. + * Call in the main thread only. + */ + private void processEvents() { + while (events_.size() > 0) { + processEvent(events_.poll()); + } + } + + /** + * Main thread only. + */ + private void processEvent(Event event) { + String name = event.name; + String namespace = event.namespace; + AttributeMap attributes = event.attributes; + switch (event.type) { + case Start: getClient().handleStartElement(name, namespace, attributes); break; + case End: getClient().handleEndElement(name, namespace); break; + case Text: getClient().handleCharacterData(name); break; + } + } + + /** + * Cause the parser thread to parse these data later. + * Note that the return code is a best guess based on previous parsing, + * and will almost always give a false negative on a stanza before a + * true negative. True negatives will always mean an error in the stream. + */ + @Override + public boolean parse(String data) { + try { + writer_.write(new ByteArray(data).getData()); + writer_.flush(); + } catch (IOException ex) { + error_ = true; + Logger.getLogger(PullXMLParser.class.getName()).log(Level.SEVERE, null, ex); + } + return !error_; + } + + +} diff --git a/src/com/isode/stroke/parser/SerializingParser.java b/src/com/isode/stroke/parser/SerializingParser.java new file mode 100644 index 0000000..1346dc8 --- /dev/null +++ b/src/com/isode/stroke/parser/SerializingParser.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.serializer.xml.XMLElement; +import com.isode.stroke.serializer.xml.XMLTextNode; +import java.util.Vector; + +public class SerializingParser { + + private final Vector<XMLElement> elementStack_ = new Vector<XMLElement>(); + private XMLElement rootElement_; + + public void handleStartElement(String tag, String ns, AttributeMap attributes) { + XMLElement element = new XMLElement(tag, ns); + for (String name : attributes.keySet()) { + element.setAttribute(name, attributes.get(name)); + } + + if (elementStack_.isEmpty()) { + rootElement_ = element; + } else { + elementStack_.lastElement().addNode(element); + } + elementStack_.add(element); + } + + public void handleEndElement(String tag, String ns) { + assert (!elementStack_.isEmpty()); + elementStack_.remove(elementStack_.size() - 1); + } + + public void handleCharacterData(String data) { + if (!elementStack_.isEmpty()) { + elementStack_.lastElement().addNode(new XMLTextNode(data)); + } + } + + public String getResult() { + return (rootElement_ != null ? rootElement_.serialize() : ""); + } +} diff --git a/src/com/isode/stroke/parser/StanzaAckParser.java b/src/com/isode/stroke/parser/StanzaAckParser.java new file mode 100644 index 0000000..40fab80 --- /dev/null +++ b/src/com/isode/stroke/parser/StanzaAckParser.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StanzaAck; + +class StanzaAckParser extends GenericElementParser<StanzaAck> { + + private int depth = 0; + + public StanzaAckParser() { + super(StanzaAck.class); + } + + @Override + public void handleStartElement(String el, String ns, AttributeMap attributes) { + if (depth == 0) { + String handledStanzasString = attributes.getAttribute("h"); + try { + getElementGeneric().setHandledStanzasCount(Long.parseLong(handledStanzasString)); + } catch (NumberFormatException e) { + + } + } + ++depth; + } + + @Override + public void handleEndElement(String el, String ns) { + --depth; + } +} diff --git a/src/com/isode/stroke/parser/StanzaAckRequestParser.java b/src/com/isode/stroke/parser/StanzaAckRequestParser.java new file mode 100644 index 0000000..9a61d7f --- /dev/null +++ b/src/com/isode/stroke/parser/StanzaAckRequestParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StanzaAckRequest; + +class StanzaAckRequestParser extends GenericElementParser<StanzaAckRequest> { + + public StanzaAckRequestParser() { + super(StanzaAckRequest.class); + } + +} diff --git a/src/com/isode/stroke/parser/StanzaParser.java b/src/com/isode/stroke/parser/StanzaParser.java new file mode 100644 index 0000000..2aa865e --- /dev/null +++ b/src/com/isode/stroke/parser/StanzaParser.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.Payload; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.jid.JID; + +public abstract class StanzaParser implements ElementParser { + + protected int currentDepth_ = 0; + protected final PayloadParserFactoryCollection factories_; + protected PayloadParser currentPayloadParser_; + + public StanzaParser(PayloadParserFactoryCollection factories) { + factories_ = factories; + } + + void handleStanzaAttributes(AttributeMap map) { + } + + Stanza getStanza() { + return (Stanza) getElement(); + } + + private boolean inPayload() { + return currentDepth_ > 1; + } + + private boolean inStanza() { + return currentDepth_ > 0; + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (inStanza()) { + if (!inPayload()) { + assert currentPayloadParser_ == null; + PayloadParserFactory payloadParserFactory = factories_.getPayloadParserFactory(element, ns, attributes); + if (payloadParserFactory != null) { + currentPayloadParser_ = payloadParserFactory.createPayloadParser(); + } else { + currentPayloadParser_ = new UnknownPayloadParser(); + } + } + assert currentPayloadParser_ != null; + currentPayloadParser_.handleStartElement(element, ns, attributes); + } else { + String from = attributes.getAttribute("from"); + if (from != null) { + getStanza().setFrom(JID.fromString(from)); + } + String to = attributes.getAttribute("to"); + if (to != null) { + getStanza().setTo(JID.fromString(to)); + } + String id = attributes.getAttribute("id"); + if (id != null) { + getStanza().setID(id); + } + handleStanzaAttributes(attributes); + } + ++currentDepth_; + } + + public void handleEndElement(String element, String ns) { + assert (inStanza()); + if (inPayload()) { + assert currentPayloadParser_ != null; + currentPayloadParser_.handleEndElement(element, ns); + --currentDepth_; + if (!inPayload()) { + Payload payload = currentPayloadParser_.getPayload(); + if (payload != null) { + getStanza().addPayload(payload); + } + currentPayloadParser_ = null; + } + } else { + --currentDepth_; + } + } + + public void handleCharacterData(String data) { + if (currentPayloadParser_ != null) { + currentPayloadParser_.handleCharacterData(data); + } + } +} diff --git a/src/com/isode/stroke/parser/StartTLSFailureParser.java b/src/com/isode/stroke/parser/StartTLSFailureParser.java new file mode 100644 index 0000000..e1a858c --- /dev/null +++ b/src/com/isode/stroke/parser/StartTLSFailureParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StartTLSFailure; + +class StartTLSFailureParser extends GenericElementParser<StartTLSFailure>{ + + public StartTLSFailureParser() { + super(StartTLSFailure.class); + } + +} diff --git a/src/com/isode/stroke/parser/StartTLSParser.java b/src/com/isode/stroke/parser/StartTLSParser.java new file mode 100644 index 0000000..c2f3e5d --- /dev/null +++ b/src/com/isode/stroke/parser/StartTLSParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StartTLSRequest; + +class StartTLSParser extends GenericElementParser<StartTLSRequest> { + + public StartTLSParser() { + super(StartTLSRequest.class); + } + +} diff --git a/src/com/isode/stroke/parser/StreamFeaturesParser.java b/src/com/isode/stroke/parser/StreamFeaturesParser.java new file mode 100644 index 0000000..7181659 --- /dev/null +++ b/src/com/isode/stroke/parser/StreamFeaturesParser.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StreamFeatures; + +class StreamFeaturesParser extends GenericElementParser<StreamFeatures> { + + public StreamFeaturesParser() { + super(StreamFeatures.class); + } + + @Override + public void handleStartElement(String element, String ns, AttributeMap unused) { + if (currentDepth_ == 1) { + if (element.equals("starttls") && ns.equals("urn:ietf:params:xml:ns:xmpp-tls")) { + getElementGeneric().setHasStartTLS(); + } else if (element.equals("session") && ns.equals("urn:ietf:params:xml:ns:xmpp-session")) { + getElementGeneric().setHasSession(); + } else if (element.equals("bind") && ns.equals("urn:ietf:params:xml:ns:xmpp-bind")) { + getElementGeneric().setHasResourceBind(); + } else if (element.equals("sm") && ns.equals("urn:xmpp:sm:2")) { + getElementGeneric().setHasStreamManagement(); + } else if (element.equals("mechanisms") && ns.equals("urn:ietf:params:xml:ns:xmpp-sasl")) { + inMechanisms_ = true; + } else if (element.equals("compression") && ns.equals("http://jabber.org/features/compress")) { + inCompression_ = true; + } + } else if (currentDepth_ == 2) { + if (inCompression_ && element.equals("method")) { + inCompressionMethod_ = true; + currentText_ = ""; + } else if (inMechanisms_ && element.equals("mechanism")) { + inMechanism_ = true; + currentText_ = ""; + } + } + ++currentDepth_; + } + + @Override + public void handleEndElement(String unused1, String unused2) { + --currentDepth_; + if (currentDepth_ == 1) { + inCompression_ = false; + inMechanisms_ = false; + } else if (currentDepth_ == 2) { + if (inCompressionMethod_) { + getElementGeneric().addCompressionMethod(currentText_); + inCompressionMethod_ = false; + } else if (inMechanism_) { + getElementGeneric().addAuthenticationMechanism(currentText_); + inMechanism_ = false; + } + } + } + + @Override + public void handleCharacterData(String data) { + currentText_ = currentText_ + data; + } + private int currentDepth_ = 0; + private String currentText_ = ""; + private boolean inMechanisms_ = false; + private boolean inMechanism_ = false; + private boolean inCompression_ = false; + private boolean inCompressionMethod_ = false; +} diff --git a/src/com/isode/stroke/parser/StreamManagementEnabledParser.java b/src/com/isode/stroke/parser/StreamManagementEnabledParser.java new file mode 100644 index 0000000..a2d12b0 --- /dev/null +++ b/src/com/isode/stroke/parser/StreamManagementEnabledParser.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2011 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StreamManagementEnabled; + +class StreamManagementEnabledParser extends GenericElementParser<StreamManagementEnabled> { + + private int level = 0; + private final static int TopLevel = 0; + + public StreamManagementEnabledParser() { + super(StreamManagementEnabled.class); + } + + @Override + public void handleStartElement(String el, String ns, AttributeMap attributes) { + if (level == TopLevel) { + if (attributes.getBoolAttribute("resume", false)) { + getElementGeneric().setResumeSupported(); + } + getElementGeneric().setResumeID(attributes.getAttribute("id")); + } + ++level; + } + + @Override + public void handleEndElement(String el, String ns) { + --level; + } +} diff --git a/src/com/isode/stroke/parser/StreamManagementFailedParser.java b/src/com/isode/stroke/parser/StreamManagementFailedParser.java new file mode 100644 index 0000000..f8c63e7 --- /dev/null +++ b/src/com/isode/stroke/parser/StreamManagementFailedParser.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StreamManagementFailed; + +class StreamManagementFailedParser extends GenericElementParser<StreamManagementFailed> { + + public StreamManagementFailedParser() { + super(StreamManagementFailed.class); + } + +} diff --git a/src/com/isode/stroke/parser/StreamResumeParser.java b/src/com/isode/stroke/parser/StreamResumeParser.java new file mode 100644 index 0000000..924e865 --- /dev/null +++ b/src/com/isode/stroke/parser/StreamResumeParser.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2011 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StreamResume; + +class StreamResumeParser extends GenericElementParser<StreamResume> { + + private int level = 0; + private final static int TopLevel = 0; + + public StreamResumeParser() { + super(StreamResume.class); + } + + @Override + public void handleStartElement(String el, String ns, AttributeMap attributes) { + if (level == TopLevel) { + String handledStanzasCount = attributes.getAttributeValue("h"); + if (handledStanzasCount != null) { + try { + getElementGeneric().setHandledStanzasCount(Long.parseLong(handledStanzasCount)); + } catch (NumberFormatException e) { + } + } + getElementGeneric().setResumeID(attributes.getAttribute("previd")); + } + ++level; + } + + @Override + public void handleEndElement(String el, String ns) { + --level; + } +} diff --git a/src/com/isode/stroke/parser/StreamResumedParser.java b/src/com/isode/stroke/parser/StreamResumedParser.java new file mode 100644 index 0000000..2a874a2 --- /dev/null +++ b/src/com/isode/stroke/parser/StreamResumedParser.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2011 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.StreamResumed; + +class StreamResumedParser extends GenericElementParser<StreamResumed> { + + private int level = 0; + private final static int TopLevel = 0; + + public StreamResumedParser() { + super(StreamResumed.class); + } + + @Override + public void handleStartElement(String el, String ns, AttributeMap attributes) { + if (level == TopLevel) { + String handledStanzasCount = attributes.getAttributeValue("h"); + if (handledStanzasCount != null) { + try { + getElementGeneric().setHandledStanzasCount(Long.parseLong(handledStanzasCount)); + } catch (NumberFormatException e) { + } + } + getElementGeneric().setResumeID(attributes.getAttribute("previd")); + } + ++level; + } + + @Override + public void handleEndElement(String el, String ns) { + --level; + } +} diff --git a/src/com/isode/stroke/parser/TLSProceedParser.java b/src/com/isode/stroke/parser/TLSProceedParser.java new file mode 100644 index 0000000..b6f196d --- /dev/null +++ b/src/com/isode/stroke/parser/TLSProceedParser.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.TLSProceed; + +class TLSProceedParser extends GenericElementParser<TLSProceed>{ + + public TLSProceedParser() { + super(TLSProceed.class); + } + +} diff --git a/src/com/isode/stroke/parser/UnknownElementParser.java b/src/com/isode/stroke/parser/UnknownElementParser.java new file mode 100644 index 0000000..cf70dd6 --- /dev/null +++ b/src/com/isode/stroke/parser/UnknownElementParser.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.UnknownElement; + +public class UnknownElementParser extends GenericElementParser<UnknownElement> { + public UnknownElementParser() { + super(UnknownElement.class); + } +} diff --git a/src/com/isode/stroke/parser/UnknownPayloadParser.java b/src/com/isode/stroke/parser/UnknownPayloadParser.java new file mode 100644 index 0000000..2bdfbae --- /dev/null +++ b/src/com/isode/stroke/parser/UnknownPayloadParser.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Payload; + +public class UnknownPayloadParser implements PayloadParser { + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + + } + + public void handleEndElement(String element, String ns) { + + } + + public void handleCharacterData(String data) { + + } + + public Payload getPayload() { + return null; + } + +} diff --git a/src/com/isode/stroke/parser/XMLParser.java b/src/com/isode/stroke/parser/XMLParser.java new file mode 100644 index 0000000..a564b12 --- /dev/null +++ b/src/com/isode/stroke/parser/XMLParser.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +public abstract class XMLParser { + private final XMLParserClient client_; + + public XMLParser(XMLParserClient client) { + client_ = client; + } + + public abstract boolean parse(String data); + + protected XMLParserClient getClient() { + return client_; + } +} diff --git a/src/com/isode/stroke/parser/XMLParserClient.java b/src/com/isode/stroke/parser/XMLParserClient.java new file mode 100644 index 0000000..5fb7071 --- /dev/null +++ b/src/com/isode/stroke/parser/XMLParserClient.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + + +public interface XMLParserClient { + void handleStartElement(String element, String ns, AttributeMap attributes); + + void handleEndElement(String element, String ns); + + void handleCharacterData(String data); +} diff --git a/src/com/isode/stroke/parser/XMPPParser.java b/src/com/isode/stroke/parser/XMPPParser.java new file mode 100644 index 0000000..c16a250 --- /dev/null +++ b/src/com/isode/stroke/parser/XMPPParser.java @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser; + +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.eventloop.EventLoop; +import java.util.logging.Logger; + + +public class XMPPParser implements XMLParserClient { + + private final XMLParser xmlParser_ ; + private final XMPPParserClient client_; + private final PayloadParserFactoryCollection payloadParserFactories_; + private int currentDepth_ = 0; + private ElementParser currentElementParser_ = null; + private boolean parseErrorOccurred_ = false; + private Logger logger_ = Logger.getLogger(this.getClass().getName()); + + public XMPPParser(XMPPParserClient parserClient, PayloadParserFactoryCollection payloadParserFactories, EventLoop eventLoop) { + client_ = parserClient; + payloadParserFactories_ = payloadParserFactories; + xmlParser_ = PlatformXMLParserFactory.createXMLParser(this, eventLoop); + } + + public boolean parse(String data) { + parseErrorOccurred_ = false; + boolean xmlParseResult = xmlParser_.parse(data); + if (parseErrorOccurred_ || !xmlParseResult) { + logger_.warning(String.format("When parsing, %b and %b", parseErrorOccurred_, xmlParseResult)); + } + return xmlParseResult && !parseErrorOccurred_; + } + + public void handleStartElement( + String element, + String ns, + AttributeMap attributes) { + if (!inStream()) { + logger_.warning("Not in stream"); + if (element.equals("stream") && ns.equals("http://etherx.jabber.org/streams")) { + ProtocolHeader header = new ProtocolHeader(); + header.setFrom(attributes.getAttribute("from")); + header.setTo(attributes.getAttribute("to")); + header.setID(attributes.getAttribute("id")); + header.setVersion(attributes.getAttribute("version")); + client_.handleStreamStart(header); + } else { + parseErrorOccurred_ = true; + } + } else { + if (!inElement()) { + assert currentElementParser_ == null; + currentElementParser_ = createElementParser(element, ns); + } + currentElementParser_.handleStartElement(element, ns, attributes); + } + ++currentDepth_; + } + + public void handleEndElement(String element, String ns) { + assert (inStream()); + if (inElement()) { + assert currentElementParser_ != null; + currentElementParser_.handleEndElement(element, ns); + --currentDepth_; + if (!inElement()) { + client_.handleElement(currentElementParser_.getElement()); + currentElementParser_ = null; + } + } else { + assert (element.equals("stream")); + --currentDepth_; + client_.handleStreamEnd(); + } + } + + public void handleCharacterData(String data) { + if (currentElementParser_ != null) { + currentElementParser_.handleCharacterData(data); + } + } + + private boolean inStream() { + return currentDepth_ > 0; + } + + private boolean inElement() { + return currentDepth_ > 1; + } + + private ElementParser createElementParser(String element, String xmlns) { + if (element.equals("presence")) { + return new PresenceParser(payloadParserFactories_); + } + else if (element.equals("iq")) { + return new IQParser(payloadParserFactories_); + } + else if (element.equals("message")) { + return new MessageParser(payloadParserFactories_); + } + else if (element.equals("features") && xmlns.equals("http://etherx.jabber.org/streams")) { + return new StreamFeaturesParser(); + } + else if (element.equals("auth")) { + return new AuthRequestParser(); + } + else if (element.equals("success")) { + return new AuthSuccessParser(); + } + else if (element.equals("failure") && xmlns.equals("urn:ietf:params:xml:ns:xmpp-sasl")) { + return new AuthFailureParser(); + } + else if (element.equals("challenge") && xmlns.equals("urn:ietf:params:xml:ns:xmpp-sasl")) { + return new AuthChallengeParser(); + } + else if (element.equals("response") && xmlns.equals("urn:ietf:params:xml:ns:xmpp-sasl")) { + return new AuthResponseParser(); + } + else if (element.equals("starttls")) { + return new StartTLSParser(); + } + else if (element.equals("failure") && xmlns.equals("urn:ietf:params:xml:ns:xmpp-tls")) { + return new StartTLSFailureParser(); + } + else if (element.equals("compress")) { + return new CompressParser(); + } + else if (element.equals("compressed")) { + return new CompressedParser(); + } + else if (element.equals("failure") && xmlns.equals("http://jabber.org/protocol/compress")) { + return new CompressFailureParser(); + } + else if (element.equals("proceed")) { + return new TLSProceedParser(); + } + else if (element.equals("enable") && xmlns.equals("urn:xmpp:sm:2")) { + return new EnableStreamManagementParser(); + } + else if (element.equals("enabled") && xmlns.equals("urn:xmpp:sm:2")) { + return new StreamManagementEnabledParser(); + } + else if (element.equals("failed") && xmlns.equals("urn:xmpp:sm:2")) { + return new StreamManagementFailedParser(); + } + else if (element.equals("resume") && xmlns.equals("urn:xmpp:sm:2")) { + return new StreamResumeParser(); + } + else if (element.equals("resumed") && xmlns.equals("urn:xmpp:sm:2")) { + return new StreamResumedParser(); + } + else if (element.equals("a") && xmlns.equals("urn:xmpp:sm:2")) { + return new StanzaAckParser(); + } + else if (element.equals("r") && xmlns.equals("urn:xmpp:sm:2")) { + return new StanzaAckRequestParser(); + } + return new UnknownElementParser(); + + } +} diff --git a/src/com/isode/stroke/parser/XMPPParserClient.java b/src/com/isode/stroke/parser/XMPPParserClient.java new file mode 100644 index 0000000..c4499cd --- /dev/null +++ b/src/com/isode/stroke/parser/XMPPParserClient.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; + +public interface XMPPParserClient { + void handleStreamStart(ProtocolHeader header); + void handleElement(Element element); + void handleStreamEnd(); +} diff --git a/src/com/isode/stroke/parser/payloadparsers/BodyParser.java b/src/com/isode/stroke/parser/payloadparsers/BodyParser.java new file mode 100644 index 0000000..3672c56 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/BodyParser.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.Body; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class BodyParser extends GenericPayloadParser<Body> { + + private int level_ = 0; + private String text_ = ""; + + public BodyParser() { + super(new Body()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + ++level_; + } + + public void handleEndElement(String element, String ns) { + --level_; + if (level_ == 0) { + getPayloadInternal().setText(text_); + } + } + + public void handleCharacterData(String data) { + text_ += data; + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/BodyParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/BodyParserFactory.java new file mode 100644 index 0000000..154281b --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/BodyParserFactory.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; + +public class BodyParserFactory extends GenericPayloadParserFactory<BodyParser> { + + public BodyParserFactory() { + super("body", BodyParser.class); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/FullPayloadParserFactoryCollection.java b/src/com/isode/stroke/parser/payloadparsers/FullPayloadParserFactoryCollection.java new file mode 100644 index 0000000..dfc1b61 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/FullPayloadParserFactoryCollection.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; +import com.isode.stroke.parser.PayloadParserFactory; +import com.isode.stroke.parser.PayloadParserFactoryCollection; + +public class FullPayloadParserFactoryCollection extends PayloadParserFactoryCollection { + public FullPayloadParserFactoryCollection() { + /* TODO: Port more */ + //addFactory(new GenericPayloadParserFactory<IBBParser>("", "http://jabber.org/protocol/ibb")); + //addFactory(new GenericPayloadParserFactory<StatusShowParser>("show", StatusShowParser.class)); + //addFactory(new GenericPayloadParserFactory<StatusParser>("status", StatusParser.class)); + //addFactory(new GenericPayloadParserFactory<ReplaceParser>("replace", "http://swift.im/protocol/replace")); + addFactory(new GenericPayloadParserFactory<LastParser>("query", "jabber:iq:last", LastParser.class)); + addFactory(new GenericPayloadParserFactory<BodyParser>("body", BodyParser.class)); + //addFactory(new GenericPayloadParserFactory<SubjectParser>("subject", SubjectParser.class)); + //addFactory(new GenericPayloadParserFactory<PriorityParser>("priority", PriorityParser.class)); + //addFactory(new ErrorParserFactory(this))); + addFactory(new SoftwareVersionParserFactory()); + //addFactory(new StorageParserFactory()); + addFactory(new RosterParserFactory()); + //addFactory(new DiscoInfoParserFactory()); + //addFactory(new DiscoItemsParserFactory()); + //addFactory(new CapsInfoParserFactory()); + addFactory(new ResourceBindParserFactory()); + addFactory(new StartSessionParserFactory()); + //addFactory(new SecurityLabelParserFactory()); + //addFactory(new SecurityLabelsCatalogParserFactory()); + //addFactory(new FormParserFactory()); + //addFactory(new CommandParserFactory()); + //addFactery(new InBandRegistrationPayloadParserFactory()); + addFactory(new SearchPayloadParserFactory()); + //addFactory(new StreamInitiationParserFactory()); + //addFactory(new BytestreamsParserFactory()); + //addFactory(new VCardUpdateParserFactory()); + //addFactory(new VCardParserFactory()); + //addFactory(new PrivateStorageParserFactory(this)); + //addFactory(new ChatStateParserFactory()); + //addFactory(new DelayParserFactory()); + //addFactory(new MUCUserPayloadParserFactory()); + //addFactory(new NicknameParserFactory()); + + + PayloadParserFactory defaultFactory = new RawXMLPayloadParserFactory(); + setDefaultFactory(defaultFactory); + } +} diff --git a/src/com/isode/stroke/parser/payloadparsers/LastParser.java b/src/com/isode/stroke/parser/payloadparsers/LastParser.java new file mode 100644 index 0000000..d2c2a82 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/LastParser.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Kevin Smith. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.Last; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class LastParser extends GenericPayloadParser<Last> { + + private int level_ = 0; + + public LastParser() { + super(new Last()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (level_ == 0) { + int seconds = 0; + + try { + seconds = Integer.parseInt(attributes.getAttribute("seconds")); + } + catch (NumberFormatException ex) { + } + getPayloadInternal().setSeconds(seconds); + } + ++level_; + } + + public void handleEndElement(String element, String ns) { + + } + + public void handleCharacterData(String data) { + + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParser.java b/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParser.java new file mode 100644 index 0000000..2a97fed --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParser.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.RawXMLPayload; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; +import com.isode.stroke.parser.SerializingParser; + +public class RawXMLPayloadParser extends GenericPayloadParser<RawXMLPayload> { + + private int level_; + private final SerializingParser serializingParser_ = new SerializingParser(); + + public RawXMLPayloadParser() { + super(new RawXMLPayload()); + } + + + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + ++level_; + serializingParser_.handleStartElement(element, ns, attributes); + } + + public void handleEndElement(String element, String ns) { + serializingParser_.handleEndElement(element, ns); + --level_; + if (level_ == 0) { + getPayloadInternal().setRawXML(serializingParser_.getResult()); + } + } + + public void handleCharacterData(String data) { + serializingParser_.handleCharacterData(data); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParserFactory.java new file mode 100644 index 0000000..e0914e1 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/RawXMLPayloadParserFactory.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.PayloadParser; +import com.isode.stroke.parser.PayloadParserFactory; + +public class RawXMLPayloadParserFactory implements PayloadParserFactory { + + public boolean canParse(String element, String ns, AttributeMap attributes) { + return true; + } + + public PayloadParser createPayloadParser() { + return new RawXMLPayloadParser(); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/ResourceBindParser.java b/src/com/isode/stroke/parser/payloadparsers/ResourceBindParser.java new file mode 100644 index 0000000..be409f4 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/ResourceBindParser.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.ResourceBind; +import com.isode.stroke.jid.JID; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class ResourceBindParser extends GenericPayloadParser<ResourceBind> { + + public ResourceBindParser() { + super(new ResourceBind()); + level_ = 0; + inJID_ = false; + inResource_ = false; + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (level_ == 1) { + text_ = ""; + if (element.equals("resource")) { + inResource_ = true; + } + if (element.equals("jid")) { + inJID_ = true; + } + } + ++level_; + } + + public void handleEndElement(String element, String ns) { + --level_; + if (level_ == 1) { + if (inJID_) { + getPayloadInternal().setJID(JID.fromString(text_)); + } else if (inResource_) { + getPayloadInternal().setResource(text_); + } + } + } + + public void handleCharacterData(String data) { + text_ += data; + } + private int level_; + private boolean inJID_; + private boolean inResource_; + private String text_ = ""; +} diff --git a/src/com/isode/stroke/parser/payloadparsers/ResourceBindParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/ResourceBindParserFactory.java new file mode 100644 index 0000000..a6b644d --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/ResourceBindParserFactory.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; + +class ResourceBindParserFactory extends GenericPayloadParserFactory<ResourceBindParser> { + + public ResourceBindParserFactory() { + super("bind", "urn:ietf:params:xml:ns:xmpp-bind", ResourceBindParser.class); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/RosterParser.java b/src/com/isode/stroke/parser/payloadparsers/RosterParser.java new file mode 100644 index 0000000..fa115c2 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/RosterParser.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.Payload; +import com.isode.stroke.elements.RosterItemPayload; +import com.isode.stroke.elements.RosterPayload; +import com.isode.stroke.jid.JID; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class RosterParser extends GenericPayloadParser<RosterPayload> { + + public RosterParser() { + super(new RosterPayload()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (level_ == PayloadLevel) { + if (element.equals("item")) { + inItem_ = true; + currentItem_ = new RosterItemPayload(); + + currentItem_.setJID(JID.fromString(attributes.getAttribute("jid"))); + currentItem_.setName(attributes.getAttribute("name")); + + String subscription = attributes.getAttribute("subscription"); + if ("both".equals(subscription)) { + currentItem_.setSubscription(RosterItemPayload.Subscription.Both); + } else if ("to".equals(subscription)) { + currentItem_.setSubscription(RosterItemPayload.Subscription.To); + } else if ("frome".equals(subscription)) { + currentItem_.setSubscription(RosterItemPayload.Subscription.From); + } else if ("remove".equals(subscription)) { + currentItem_.setSubscription(RosterItemPayload.Subscription.Remove); + } else { + currentItem_.setSubscription(RosterItemPayload.Subscription.None); + } + + if ("subscribe".equals(attributes.getAttribute("ask"))) { + currentItem_.setSubscriptionRequested(); + } + } + } else if (level_ == ItemLevel) { + if (element.equals("group")) { + currentText_ = ""; + } + } + ++level_; + } + + public void handleEndElement(String element, String ns) { + --level_; + if (level_ == PayloadLevel) { + if (inItem_) { + getPayloadInternal().addItem(currentItem_); + inItem_ = false; + } + } else if (level_ == ItemLevel) { + if (element.equals("group")) { + currentItem_.addGroup(currentText_); + } + } + } + + public void handleCharacterData(String data) { + currentText_ += data; + } + private final int TopLevel = 0; + private final int PayloadLevel = 1; + private final int ItemLevel = 2; + private int level_ = TopLevel; + private boolean inItem_ = false; + private RosterItemPayload currentItem_; + private String currentText_; +} diff --git a/src/com/isode/stroke/parser/payloadparsers/RosterParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/RosterParserFactory.java new file mode 100644 index 0000000..ad690e1 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/RosterParserFactory.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; + +public class RosterParserFactory extends GenericPayloadParserFactory<RosterParser> { + + public RosterParserFactory() { + super("query", "jabber:iq:roster", RosterParser.class); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParser.java b/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParser.java new file mode 100644 index 0000000..0ee1499 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParser.java @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.SearchPayload; +import com.isode.stroke.jid.JID; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class SearchPayloadParser extends GenericPayloadParser<SearchPayload> { + + private static final int TopLevel = 0; + private static final int PayloadLevel = 1; + private static final int ItemLevel = 2; + + private int level = 0; + private String currentText = ""; + //private FormParserFactory formParserFactory = new FormParserFactory(); /* Not ported yet*/ + //private FormParser formParser; + SearchPayload.Item currentItem; + + public SearchPayloadParser() { + super(new SearchPayload()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + if (level == TopLevel) { + } + else if (level == PayloadLevel) { + //if (element.equals("x") && ns.equals("jabber:x:data")) { + // assert formParser == null; + // formParser = dynamic_cast<FormParser*>(formParserFactory->createPayloadParser()); + //} /* Not ported yet */ + //else + if (element.equals("item")) { + assert currentItem == null; + currentItem = new SearchPayload.Item(); + currentItem.jid = JID.fromString(attributes.getAttribute("jid")); + } + else { + currentText = ""; + } + } + else if (level == ItemLevel && currentItem != null) { + currentText = ""; + } + + //if (formParser) { + // formParser->handleStartElement(element, ns, attributes); + //} /* Not ported yet */ + + ++level; + } + + public void handleEndElement(String element, String ns) { + --level; + + //if (formParser) { + // formParser->handleEndElement(element, ns); + //} /*Not Ported yet*/ + + if (level == TopLevel) { + } + else if (level == PayloadLevel) { + //if (formParser) { + // getPayloadInternal()->setForm(formParser->getPayloadInternal()); + // delete formParser; + // formParser = NULL; + //} + //else /*Not ported yet*/ + if (element.equals("item")) { + assert currentItem != null; + getPayloadInternal().addItem(currentItem); + currentItem = null; + } + else if (element.equals("instructions")) { + getPayloadInternal().setInstructions(currentText); + } + else if (element.equals("nick")) { + getPayloadInternal().setNick(currentText); + } + else if (element.equals("first")) { + getPayloadInternal().setFirst(currentText); + } + else if (element.equals("last")) { + getPayloadInternal().setLast(currentText); + } + else if (element.equals("email")) { + getPayloadInternal().setEMail(currentText); + } + } + else if (level == ItemLevel && currentItem != null) { + if (element.equals("nick")) { + currentItem.nick = currentText; + } + else if (element.equals("first")) { + currentItem.first = currentText; + } + else if (element.equals("last")) { + currentItem.last = currentText; + } + else if (element.equals("email")) { + currentItem.email = currentText; + } + } + } + + public void handleCharacterData(String data) { + //if (formParser) { + // formParser->handleCharacterData(data); + //} + //else { /*Not ported yet*/ + currentText += data; + //} + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParserFactory.java new file mode 100644 index 0000000..4add0a1 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/SearchPayloadParserFactory.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; +import com.isode.stroke.parser.PayloadParser; + +public class SearchPayloadParserFactory extends GenericPayloadParserFactory<SearchPayloadParser> { + + public SearchPayloadParserFactory() { + super("query", "jabber:iq:search", SearchPayloadParser.class); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParser.java b/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParser.java new file mode 100644 index 0000000..93563a3 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParser.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.Version; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class SoftwareVersionParser extends GenericPayloadParser<Version> { + + public SoftwareVersionParser() { + super(new Version()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + level_++; + } + + public void handleEndElement(String element, String ns) { + --level_; + if (level_ == PayloadLevel) { + if (element.equals("name")) { + getPayloadInternal().setName(currentText_); + } else if (element.equals("version")) { + getPayloadInternal().setVersion(currentText_); + } else if (element.equals("os")) { + getPayloadInternal().setOS(currentText_); + } + currentText_ = ""; + } + + } + + public void handleCharacterData(String data) { + currentText_ += data; + } + + private static final int TopLevel = 0; + private static final int PayloadLevel = 1; + private int level_ = TopLevel; + private String currentText_ = ""; + + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParserFactory.java new file mode 100644 index 0000000..e2180f5 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/SoftwareVersionParserFactory.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; + +public class SoftwareVersionParserFactory extends GenericPayloadParserFactory<SoftwareVersionParser> { + + public SoftwareVersionParserFactory() { + super("query", "jabber:iq:version", SoftwareVersionParser.class); + } + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/StartSessionParser.java b/src/com/isode/stroke/parser/payloadparsers/StartSessionParser.java new file mode 100644 index 0000000..ba7804c --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/StartSessionParser.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.elements.StartSession; +import com.isode.stroke.parser.AttributeMap; +import com.isode.stroke.parser.GenericPayloadParser; + +public class StartSessionParser extends GenericPayloadParser<StartSession> { + + public StartSessionParser() { + super(new StartSession()); + } + + public void handleStartElement(String element, String ns, AttributeMap attributes) { + + } + + public void handleEndElement(String element, String ns) { + + } + + public void handleCharacterData(String data) { + + } + + +} diff --git a/src/com/isode/stroke/parser/payloadparsers/StartSessionParserFactory.java b/src/com/isode/stroke/parser/payloadparsers/StartSessionParserFactory.java new file mode 100644 index 0000000..c2c9777 --- /dev/null +++ b/src/com/isode/stroke/parser/payloadparsers/StartSessionParserFactory.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.parser.payloadparsers; + +import com.isode.stroke.parser.GenericPayloadParserFactory; + +class StartSessionParserFactory extends GenericPayloadParserFactory<StartSessionParser> { + + public StartSessionParserFactory() { + super("session", "urn:ietf:params:xml:ns:xmpp-session", StartSessionParser.class); + } + +} diff --git a/src/com/isode/stroke/queries/GenericRequest.java b/src/com/isode/stroke/queries/GenericRequest.java new file mode 100644 index 0000000..cfbfb52 --- /dev/null +++ b/src/com/isode/stroke/queries/GenericRequest.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010, 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.ErrorPayload; +import com.isode.stroke.elements.IQ; +import com.isode.stroke.elements.Payload; +import com.isode.stroke.jid.JID; +import com.isode.stroke.signals.Signal2; + +/** + * IQ Request for standard payload. + */ +public class GenericRequest<T extends Payload> extends Request { + + public Signal2<T, ErrorPayload> onResponse = new Signal2<T, ErrorPayload>(); + + public GenericRequest(IQ.Type type, JID receiver, Payload payload, IQRouter router) { + super(type, receiver, payload, router); + } + + @Override + protected void handleResponse(Payload payload, ErrorPayload error) { + T genericPayload = null; + try { + genericPayload = (T)payload; + } catch (Exception ex) { + /* This isn't legal XMPP, so treat as NULL.*/ + } + onResponse.emit(genericPayload, error); + } + + protected T getPayloadGeneric() { + return (T)getPayload(); + } + +} diff --git a/src/com/isode/stroke/queries/GetRosterRequest.java b/src/com/isode/stroke/queries/GetRosterRequest.java new file mode 100644 index 0000000..1c7ea6e --- /dev/null +++ b/src/com/isode/stroke/queries/GetRosterRequest.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.IQ.Type; +import com.isode.stroke.elements.RosterPayload; +import com.isode.stroke.jid.JID; + +public class GetRosterRequest extends GenericRequest<RosterPayload> { + public GetRosterRequest(JID target, IQRouter iqRouter) { + super(Type.Get, target, new RosterPayload(), iqRouter); + } + + public GetRosterRequest(IQRouter iqRouter) { + super(Type.Get, new JID(), new RosterPayload(), iqRouter); + } +} diff --git a/src/com/isode/stroke/queries/GetVersionRequest.java b/src/com/isode/stroke/queries/GetVersionRequest.java new file mode 100644 index 0000000..75db384 --- /dev/null +++ b/src/com/isode/stroke/queries/GetVersionRequest.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.IQ.Type; +import com.isode.stroke.elements.Version; +import com.isode.stroke.jid.JID; + +public class GetVersionRequest extends GenericRequest<Version> { + public GetVersionRequest(JID target, IQRouter iqRouter) { + super(Type.Get, target, new Version(), iqRouter); + } + + public GetVersionRequest(IQRouter iqRouter) { + super(Type.Get, new JID(), new Version(), iqRouter); + } +} diff --git a/src/com/isode/stroke/queries/IQChannel.java b/src/com/isode/stroke/queries/IQChannel.java new file mode 100644 index 0000000..fd5fe8e --- /dev/null +++ b/src/com/isode/stroke/queries/IQChannel.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.IQ; +import com.isode.stroke.signals.Signal1; + +public abstract class IQChannel { + + public abstract void sendIQ(IQ iq); + + public abstract String getNewIQID(); + + public abstract boolean isAvailable(); + + public final Signal1<IQ> onIQReceived = new Signal1<IQ>(); +} diff --git a/src/com/isode/stroke/queries/IQHandler.java b/src/com/isode/stroke/queries/IQHandler.java new file mode 100644 index 0000000..2d6f35e --- /dev/null +++ b/src/com/isode/stroke/queries/IQHandler.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.IQ; + +/** + * Thing reacting to IQs. + */ +public interface IQHandler { + boolean handleIQ(IQ iq); +} diff --git a/src/com/isode/stroke/queries/IQReceivedHandler.java b/src/com/isode/stroke/queries/IQReceivedHandler.java new file mode 100644 index 0000000..37db43a --- /dev/null +++ b/src/com/isode/stroke/queries/IQReceivedHandler.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.IQ; + +interface IQReceivedHandler { + void handleIQ(IQ iq); +} diff --git a/src/com/isode/stroke/queries/IQRouter.java b/src/com/isode/stroke/queries/IQRouter.java new file mode 100644 index 0000000..04ddb20 --- /dev/null +++ b/src/com/isode/stroke/queries/IQRouter.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.queries; + +import com.isode.stroke.elements.ErrorPayload; +import com.isode.stroke.elements.IQ; +import com.isode.stroke.signals.Slot1; +import java.util.Vector; + +/** + * Route IQs to handlers + */ +public class IQRouter { + + private final Vector<IQHandler> handlers_ = new Vector<IQHandler>(); + private final IQChannel channel_; + + public IQRouter(IQChannel channel) { + channel_ = channel; + final IQRouter thisObject = this; + channel_.onIQReceived.connect(new Slot1<IQ>() { + + public void call(IQ p1) { + handleIQ(p1); + } + }); + } + + public void addHandler(IQHandler handler) { + synchronized (handlers_) { + handlers_.add(handler); + } + } + + public void removeHandler(IQHandler handler) { + synchronized (handlers_) { + handlers_.remove(handler); + } + } + + public void sendIQ(IQ iq) { + channel_.sendIQ(iq); + } + + public String getNewIQID() { + return channel_.getNewIQID(); + } + + public boolean isAvailable() { + return channel_.isAvailable(); + } + + private void handleIQ(IQ iq) { + boolean handled = false; + synchronized (handlers_) { + for (IQHandler handler : handlers_) { + handled |= handler.handleIQ(iq); + if (handled) { + break; + } + } + } + if (!handled && (iq.getType().equals(IQ.Type.Get) || iq.getType().equals(IQ.Type.Set))) { + sendIQ(IQ.createError(iq.getFrom(), iq.getID(), ErrorPayload.Condition.FeatureNotImplemented, ErrorPayload.Type.Cancel)); + } + } +} diff --git a/src/com/isode/stroke/queries/Request.java b/src/com/isode/stroke/queries/Request.java new file mode 100644 index 0000000..df38b10 --- /dev/null +++ b/src/com/isode/stroke/queries/Request.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.queries; + +import com.isode.stroke.elements.ErrorPayload; +import com.isode.stroke.elements.IQ; +import com.isode.stroke.elements.IQ.Type; +import com.isode.stroke.elements.Payload; +import com.isode.stroke.jid.JID; + +/** + * Base class for IQ requests. + */ +public abstract class Request implements IQHandler { + protected final Type type_; + protected final IQRouter router_; + protected final JID receiver_; + private boolean sent_; + private Payload payload_; + private String id_; + + public Request(IQ.Type type, JID receiver, IQRouter router) { + this(type, receiver, null, router); + } + + public Request(IQ.Type type, JID receiver, Payload payload, IQRouter router) { + type_ = type; + router_ = router; + receiver_ = receiver; + payload_ = payload; + sent_ = false; + } + + public void send() { + assert payload_ != null; + assert !sent_; + sent_ = true; + + IQ iq = new IQ(type_); + iq.setTo(receiver_); + iq.addPayload(payload_); + id_ = router_.getNewIQID(); + iq.setID(id_); + + router_.addHandler(this); + + router_.sendIQ(iq); + } + + protected void setPayload(Payload payload) { + payload_ = payload; + } + + protected Payload getPayload() { + return payload_; + } + + protected abstract void handleResponse(Payload payload, ErrorPayload error); + + public boolean handleIQ(IQ iq) { + boolean handled = false; + if (sent_ && iq.getID().equals(id_)) { + if (iq.getType().equals(IQ.Type.Result)) { + handleResponse(iq.getPayload(payload_), null); + } else { + ErrorPayload errorPayload = iq.getPayload(new ErrorPayload()); + if (errorPayload != null) { + handleResponse(null, errorPayload); + } else { + handleResponse(null, new ErrorPayload(ErrorPayload.Condition.UndefinedCondition)); + } + } + router_.removeHandler(this); + handled = true; + } + return handled; + } + +}
\ No newline at end of file diff --git a/src/com/isode/stroke/sasl/ClientAuthenticator.java b/src/com/isode/stroke/sasl/ClientAuthenticator.java new file mode 100644 index 0000000..e8fcff9 --- /dev/null +++ b/src/com/isode/stroke/sasl/ClientAuthenticator.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.sasl; + +import com.isode.stroke.base.ByteArray; + +public abstract class ClientAuthenticator { + + public ClientAuthenticator(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public void setCredentials(String authcid, String password) { + setCredentials(authcid, password, ""); + } + + public void setCredentials(String authcid, String password, String authzid) { + this.authcid = authcid; + this.password = password; + this.authzid = authzid; + } + + public abstract ByteArray getResponse(); + + public abstract boolean setChallenge(ByteArray challenge); + + public String getAuthenticationID() { + return authcid; + } + + public String getAuthorizationID() { + return authzid; + } + + public String getPassword() { + return password; + } + private String name; + private String authcid; + private String password; + private String authzid; +} diff --git a/src/com/isode/stroke/sasl/PLAINClientAuthenticator.java b/src/com/isode/stroke/sasl/PLAINClientAuthenticator.java new file mode 100644 index 0000000..889ac54 --- /dev/null +++ b/src/com/isode/stroke/sasl/PLAINClientAuthenticator.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.sasl; + +import com.isode.stroke.base.ByteArray; + +public class PLAINClientAuthenticator extends ClientAuthenticator { + public PLAINClientAuthenticator() { + super("PLAIN"); + } + + public ByteArray getResponse() { + return new ByteArray().append(getAuthorizationID()).append((byte)0).append(getAuthenticationID()).append((byte)0).append(getPassword()); + } + + public boolean setChallenge(ByteArray challenge) { + return true; + } +} + diff --git a/src/com/isode/stroke/sasl/SCRAMSHA1ClientAuthenticator.java b/src/com/isode/stroke/sasl/SCRAMSHA1ClientAuthenticator.java new file mode 100644 index 0000000..da44d85 --- /dev/null +++ b/src/com/isode/stroke/sasl/SCRAMSHA1ClientAuthenticator.java @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.sasl; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.stringcodecs.Base64; +import com.isode.stroke.stringcodecs.HMACSHA1; +import com.isode.stroke.stringcodecs.PBKDF2; +import com.isode.stroke.stringcodecs.SHA1; +import java.text.Normalizer; +import java.text.Normalizer.Form; +import java.util.HashMap; +import java.util.Map; + +public class SCRAMSHA1ClientAuthenticator extends ClientAuthenticator { + + static String escape(String s) { + String result = ""; + for (int i = 0; i < s.length(); ++i) { + if (s.charAt(i) == ',') { + result += "=2C"; + } else if (s.charAt(i) == '=') { + result += "=3D"; + } else { + result += s.charAt(i); + } + } + return result; + } + + public SCRAMSHA1ClientAuthenticator(String nonce) { + this(nonce, false); + } + public SCRAMSHA1ClientAuthenticator(String nonce, boolean useChannelBinding) { + super(useChannelBinding ? "SCRAM-SHA-1-PLUS" : "SCRAM-SHA-1"); + step = Step.Initial; + clientnonce = nonce; + this.useChannelBinding = useChannelBinding; + } + + public void setTLSChannelBindingData(ByteArray channelBindingData) { + tlsChannelBindingData = channelBindingData; + } + + public ByteArray getResponse() { + if (step.equals(Step.Initial)) { + return ByteArray.plus(getGS2Header(), getInitialBareClientMessage()); + } else if (step.equals(Step.Proof)) { + ByteArray clientKey = HMACSHA1.getResult(saltedPassword, new ByteArray("Client Key")); + ByteArray storedKey = SHA1.getHash(clientKey); + ByteArray clientSignature = HMACSHA1.getResult(storedKey, authMessage); + ByteArray clientProof = clientKey; + byte[] clientProofData = clientProof.getData(); + for (int i = 0; i < clientProofData.length; ++i) { + clientProofData[i] ^= clientSignature.getData()[i]; + } + ByteArray result = getFinalMessageWithoutProof().append(",p=").append(Base64.encode(clientProof)); + return result; + } else { + return null; + } + } + + public boolean setChallenge(ByteArray challenge) { + if (step.equals(Step.Initial)) { + if (challenge == null) { + return false; + } + initialServerMessage = challenge; + + Map<Character, String> keys = parseMap(initialServerMessage.toString()); + + // Extract the salt + ByteArray salt = Base64.decode(keys.get('s')); + + // Extract the server nonce + String clientServerNonce = keys.get('r'); + if (clientServerNonce.length() <= clientnonce.length()) { + return false; + } + String receivedClientNonce = clientServerNonce.substring(0, clientnonce.length()); + if (!receivedClientNonce.equals(clientnonce)) { + return false; + } + serverNonce = new ByteArray(clientServerNonce.substring(clientnonce.length())); + + + // Extract the number of iterations + int iterations = 0; + try { + iterations = Integer.parseInt(keys.get('i')); + } catch (NumberFormatException e) { + return false; + } + if (iterations <= 0) { + return false; + } + + ByteArray channelBindData = new ByteArray(); + if (useChannelBinding && tlsChannelBindingData != null) { + channelBindData = tlsChannelBindingData; + } + + // Compute all the values needed for the server signature + saltedPassword = PBKDF2.encode(new ByteArray(SASLPrep(getPassword())), salt, iterations); + authMessage = getInitialBareClientMessage().append(",").append(initialServerMessage).append(",").append(getFinalMessageWithoutProof()); + ByteArray serverKey = HMACSHA1.getResult(saltedPassword, new ByteArray("Server Key")); + serverSignature = HMACSHA1.getResult(serverKey, authMessage); + + step = Step.Proof; + return true; + } else if (step.equals(step.Proof)) { + ByteArray result = new ByteArray("v=").append(new ByteArray(Base64.encode(serverSignature))); + step = Step.Final; + return challenge != null && challenge.equals(result); + } else { + return true; + } + } + + private String SASLPrep(String source) { + return Normalizer.normalize(source, Form.NFKC); /* FIXME: Implement real SASLPrep */ + } + + private Map<Character, String> parseMap(String s) { + HashMap<Character, String> result = new HashMap<Character, String>(); + if (s.length() > 0) { + char key = '~'; /* initialise so it'll compile */ + String value = ""; + int i = 0; + boolean expectKey = true; + while (i < s.length()) { + if (expectKey) { + key = s.charAt(i); + expectKey = false; + i++; + } else if (s.charAt(i) == ',') { + result.put(key, value); + value = ""; + expectKey = true; + } else { + value += s.charAt(i); + } + i++; + } + result.put(key, value); + } + return result; + } + + private ByteArray getInitialBareClientMessage() { + String authenticationID = SASLPrep(getAuthenticationID()); + return new ByteArray("n=" + escape(authenticationID) + ",r=" + clientnonce); + } + + private ByteArray getGS2Header() { + + ByteArray channelBindingHeader = new ByteArray("n"); + if (tlsChannelBindingData != null) { + if (useChannelBinding) { + channelBindingHeader = new ByteArray("p=tls-unique"); + } + else { + channelBindingHeader = new ByteArray("y"); + } + } + return new ByteArray().append(channelBindingHeader).append(",").append(getAuthorizationID().isEmpty() ? new ByteArray() : new ByteArray("a=" + escape(getAuthorizationID()))).append(","); + } + + private ByteArray getFinalMessageWithoutProof() { + ByteArray channelBindData = new ByteArray(); + if (useChannelBinding && tlsChannelBindingData != null) { + channelBindData = tlsChannelBindingData; + } + return new ByteArray("c=" + Base64.encode(new ByteArray(getGS2Header()).append(channelBindData)) + ",r=" + clientnonce).append(serverNonce); + } + + private enum Step { + + Initial, + Proof, + Final + }; + private Step step; + private String clientnonce = ""; + private ByteArray initialServerMessage = new ByteArray(); + private ByteArray serverNonce = new ByteArray(); + private ByteArray authMessage = new ByteArray(); + private ByteArray saltedPassword = new ByteArray(); + private ByteArray serverSignature = new ByteArray(); + private boolean useChannelBinding; + private ByteArray tlsChannelBindingData; +} diff --git a/src/com/isode/stroke/serializer/AuthChallengeSerializer.java b/src/com/isode/stroke/serializer/AuthChallengeSerializer.java new file mode 100644 index 0000000..eee392e --- /dev/null +++ b/src/com/isode/stroke/serializer/AuthChallengeSerializer.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.AuthChallenge; +import com.isode.stroke.elements.Element; +import com.isode.stroke.stringcodecs.Base64; + +class AuthChallengeSerializer extends GenericElementSerializer<AuthChallenge> { + + public AuthChallengeSerializer() { + super(AuthChallenge.class); + } + + public String serialize(Element element) { + AuthChallenge authChallenge = (AuthChallenge)element; + String value = ""; + ByteArray message = authChallenge.getValue(); + if (message != null) { + if (message.isEmpty()) { + value = "="; + } + else { + value = Base64.encode(message); + } + } + return "<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</challenge>"; + } + +} diff --git a/src/com/isode/stroke/serializer/AuthFailureSerializer.java b/src/com/isode/stroke/serializer/AuthFailureSerializer.java new file mode 100644 index 0000000..e75a0f4 --- /dev/null +++ b/src/com/isode/stroke/serializer/AuthFailureSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.AuthFailure; +import com.isode.stroke.elements.Element; +import com.isode.stroke.serializer.xml.XMLElement; + +class AuthFailureSerializer extends GenericElementSerializer<AuthFailure>{ + + public AuthFailureSerializer() { + super(AuthFailure.class); + } + + public String serialize(Element element) { + return new XMLElement("failure", "urn:ietf:params:xml:ns:xmpp-sasl").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/AuthRequestSerializer.java b/src/com/isode/stroke/serializer/AuthRequestSerializer.java new file mode 100644 index 0000000..eb3fbd5 --- /dev/null +++ b/src/com/isode/stroke/serializer/AuthRequestSerializer.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.AuthRequest; +import com.isode.stroke.elements.Element; +import com.isode.stroke.stringcodecs.Base64; + +class AuthRequestSerializer extends GenericElementSerializer<AuthRequest> { + + public AuthRequestSerializer() { + super(AuthRequest.class); + } + + public String serialize(Element element) { + AuthRequest authRequest = (AuthRequest)element; + String value = ""; + ByteArray message = authRequest.getMessage(); + if (message != null) { + if (message.isEmpty()) { + value = "="; + } + else { + value = Base64.encode(message); + } + } + return "<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"" + authRequest.getMechanism() + "\">" + value + "</auth>"; + } + +} diff --git a/src/com/isode/stroke/serializer/AuthResponseSerializer.java b/src/com/isode/stroke/serializer/AuthResponseSerializer.java new file mode 100644 index 0000000..b65f4b1 --- /dev/null +++ b/src/com/isode/stroke/serializer/AuthResponseSerializer.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.AuthResponse; +import com.isode.stroke.elements.Element; +import com.isode.stroke.stringcodecs.Base64; + +class AuthResponseSerializer extends GenericElementSerializer<AuthResponse> { + + public AuthResponseSerializer() { + super(AuthResponse.class); + } + + public String serialize(Element element) { + AuthResponse authResponse = (AuthResponse) element; + String value = ""; + ByteArray message = authResponse.getValue(); + if (message != null) { + if (message.isEmpty()) { + value = "="; + } else { + value = Base64.encode(message); + } + } + return "<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</response>"; + } +} diff --git a/src/com/isode/stroke/serializer/AuthSuccessSerializer.java b/src/com/isode/stroke/serializer/AuthSuccessSerializer.java new file mode 100644 index 0000000..1b8be25 --- /dev/null +++ b/src/com/isode/stroke/serializer/AuthSuccessSerializer.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.AuthSuccess; +import com.isode.stroke.elements.Element; +import com.isode.stroke.stringcodecs.Base64; + + +class AuthSuccessSerializer extends GenericElementSerializer<AuthSuccess> { + + public AuthSuccessSerializer() { + super(AuthSuccess.class); + } + + public String serialize(Element element) { + AuthSuccess authSuccess = (AuthSuccess)element; + String value = ""; + ByteArray message = authSuccess.getValue(); + if (message != null) { + if (message.isEmpty()) { + value = "="; + } + else { + value = Base64.encode(message); + } + } + return "<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</success>"; + } + +} diff --git a/src/com/isode/stroke/serializer/CompressFailureSerializer.java b/src/com/isode/stroke/serializer/CompressFailureSerializer.java new file mode 100644 index 0000000..fe31f27 --- /dev/null +++ b/src/com/isode/stroke/serializer/CompressFailureSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.CompressFailure; +import com.isode.stroke.elements.Element; +import com.isode.stroke.serializer.xml.XMLElement; + +class CompressFailureSerializer extends GenericElementSerializer<CompressFailure> { + + public CompressFailureSerializer() { + super(CompressFailure.class); + } + + public String serialize(Element element) { + return new XMLElement("failure", "http://jabber.org/protocol/compress").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/CompressRequestSerializer.java b/src/com/isode/stroke/serializer/CompressRequestSerializer.java new file mode 100644 index 0000000..512e178 --- /dev/null +++ b/src/com/isode/stroke/serializer/CompressRequestSerializer.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.CompressRequest; +import com.isode.stroke.elements.Element; + +class CompressRequestSerializer implements ElementSerializer { + + public CompressRequestSerializer() { + } + + public String serialize(Element element) { + CompressRequest compressRequest = (CompressRequest) element; + return "<compress xmlns='http://jabber.org/protocol/compress'><method>" + compressRequest.getMethod() + "</method></compress>"; + } + + public boolean canSerialize(Element element) { + return element instanceof CompressRequest; + } +} diff --git a/src/com/isode/stroke/serializer/ElementSerializer.java b/src/com/isode/stroke/serializer/ElementSerializer.java new file mode 100644 index 0000000..8f4ade7 --- /dev/null +++ b/src/com/isode/stroke/serializer/ElementSerializer.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; + +public interface ElementSerializer { + String serialize(Element element); + boolean canSerialize(Element element); +} diff --git a/src/com/isode/stroke/serializer/EnableStreamManagementSerializer.java b/src/com/isode/stroke/serializer/EnableStreamManagementSerializer.java new file mode 100644 index 0000000..8862bb3 --- /dev/null +++ b/src/com/isode/stroke/serializer/EnableStreamManagementSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.EnableStreamManagement; +import com.isode.stroke.serializer.xml.XMLElement; + +class EnableStreamManagementSerializer extends GenericElementSerializer<EnableStreamManagement> { + + public EnableStreamManagementSerializer() { + super(EnableStreamManagement.class); + } + + public String serialize(Element element) { + return new XMLElement("enable", "urn:xmpp:sm:2").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/GenericElementSerializer.java b/src/com/isode/stroke/serializer/GenericElementSerializer.java new file mode 100644 index 0000000..ecd5bf4 --- /dev/null +++ b/src/com/isode/stroke/serializer/GenericElementSerializer.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; + +public abstract class GenericElementSerializer<T> implements ElementSerializer { + + private final Class elementClass_; + + GenericElementSerializer(Class elementClass) { + elementClass_ = elementClass; + } + + public boolean canSerialize(Element element) { + return elementClass_.isAssignableFrom(element.getClass()); + } + + +}
\ No newline at end of file diff --git a/src/com/isode/stroke/serializer/GenericPayloadSerializer.java b/src/com/isode/stroke/serializer/GenericPayloadSerializer.java new file mode 100644 index 0000000..3f5c92e --- /dev/null +++ b/src/com/isode/stroke/serializer/GenericPayloadSerializer.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Payload; + +public abstract class GenericPayloadSerializer<T extends Payload> extends PayloadSerializer { + + private final Class class_; + + public GenericPayloadSerializer(Class c) { + class_ = c; + } + + @Override + public boolean canSerialize(Payload payload) { + return class_.isAssignableFrom(payload.getClass()); + } + + @Override + public String serialize(Payload payload) { + return serializePayload((T)payload); + } + + protected abstract String serializePayload(T payload); + +} diff --git a/src/com/isode/stroke/serializer/GenericStanzaSerializer.java b/src/com/isode/stroke/serializer/GenericStanzaSerializer.java new file mode 100644 index 0000000..89ac1d1 --- /dev/null +++ b/src/com/isode/stroke/serializer/GenericStanzaSerializer.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.serializer.xml.XMLElement; + +public abstract class GenericStanzaSerializer<T extends Stanza> extends StanzaSerializer { + + private final Class stanzaClass_; + + GenericStanzaSerializer(Class stanzaClass, String tag, PayloadSerializerCollection payloadSerializers) { + super(tag, payloadSerializers); + stanzaClass_ = stanzaClass; + } + + public boolean canSerialize(Element element) { + return stanzaClass_.isAssignableFrom(element.getClass()); + } + + public void setStanzaSpecificAttributes(Element stanza, XMLElement element) { + setStanzaSpecificAttributesGeneric((T)stanza, element); + } + + abstract void setStanzaSpecificAttributesGeneric(T stanza, XMLElement element); +} diff --git a/src/com/isode/stroke/serializer/IQSerializer.java b/src/com/isode/stroke/serializer/IQSerializer.java new file mode 100644 index 0000000..0025aad --- /dev/null +++ b/src/com/isode/stroke/serializer/IQSerializer.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.IQ; +import com.isode.stroke.serializer.xml.XMLElement; + +public class IQSerializer extends GenericStanzaSerializer<IQ> { + + public IQSerializer(PayloadSerializerCollection payloadSerializers) { + super(IQ.class, "iq", payloadSerializers); + } + + @Override + void setStanzaSpecificAttributesGeneric(IQ iq, XMLElement element) { + switch (iq.getType()) { + case Get: + element.setAttribute("type", "get"); + break; + case Set: + element.setAttribute("type", "set"); + break; + case Result: + element.setAttribute("type", "result"); + break; + case Error: + element.setAttribute("type", "error"); + break; + } + } +} diff --git a/src/com/isode/stroke/serializer/MessageSerializer.java b/src/com/isode/stroke/serializer/MessageSerializer.java new file mode 100644 index 0000000..27d5c73 --- /dev/null +++ b/src/com/isode/stroke/serializer/MessageSerializer.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Message; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.serializer.xml.XMLElement; + +public class MessageSerializer extends GenericStanzaSerializer<Message>{ + + public MessageSerializer(PayloadSerializerCollection payloadSerializers) { + super(Message.class, "message", payloadSerializers); + } + + @Override + void setStanzaSpecificAttributesGeneric(Message message, XMLElement element) { + if (message.getType().equals(Message.Type.Chat)) { + element.setAttribute("type", "chat"); + } + else if (message.getType().equals(Message.Type.Groupchat)) { + element.setAttribute("type", "groupchat"); + } + else if (message.getType().equals(Message.Type.Headline)) { + element.setAttribute("type", "headline"); + } + else if (message.getType().equals(Message.Type.Error)) { + element.setAttribute("type", "error"); + } + } + +} diff --git a/src/com/isode/stroke/serializer/PayloadSerializer.java b/src/com/isode/stroke/serializer/PayloadSerializer.java new file mode 100644 index 0000000..2d15408 --- /dev/null +++ b/src/com/isode/stroke/serializer/PayloadSerializer.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Payload; + +/** + * Serialise a particular payload. + */ +public abstract class PayloadSerializer { + public abstract boolean canSerialize(Payload payload); + public abstract String serialize(Payload payload); +} diff --git a/src/com/isode/stroke/serializer/PayloadSerializerCollection.java b/src/com/isode/stroke/serializer/PayloadSerializerCollection.java new file mode 100644 index 0000000..49ffe41 --- /dev/null +++ b/src/com/isode/stroke/serializer/PayloadSerializerCollection.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Payload; +import java.util.Vector; + +public class PayloadSerializerCollection { + + private final Vector<PayloadSerializer> serializers_ = new Vector<PayloadSerializer>(); + + public void addSerializer(PayloadSerializer serializer) { + synchronized (serializers_) { + serializers_.add(serializer); + } + } + + public PayloadSerializer getPayloadSerializer(Payload payload) { + synchronized (serializers_) { + for (PayloadSerializer serializer : serializers_) { + if (serializer.canSerialize(payload)) { + return serializer; + } + } + } + return null; + } +} diff --git a/src/com/isode/stroke/serializer/PresenceSerializer.java b/src/com/isode/stroke/serializer/PresenceSerializer.java new file mode 100644 index 0000000..a7439f7 --- /dev/null +++ b/src/com/isode/stroke/serializer/PresenceSerializer.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Presence; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.serializer.xml.XMLElement; + +public class PresenceSerializer extends GenericStanzaSerializer<Presence> { +public PresenceSerializer(PayloadSerializerCollection payloadSerializers) { + super(Presence.class, "presence", payloadSerializers); +} + + @Override + void setStanzaSpecificAttributesGeneric(Presence presence, XMLElement element) { + switch (presence.getType()) { + case Unavailable: element.setAttribute("type","unavailable"); break; + case Probe: element.setAttribute("type","probe"); break; + case Subscribe: element.setAttribute("type","subscribe"); break; + case Subscribed: element.setAttribute("type","subscribed"); break; + case Unsubscribe: element.setAttribute("type","unsubscribe"); break; + case Unsubscribed: element.setAttribute("type","unsubscribed"); break; + case Error: element.setAttribute("type","error"); break; + case Available: break; + } + } + + +} diff --git a/src/com/isode/stroke/serializer/StanzaAckRequestSerializer.java b/src/com/isode/stroke/serializer/StanzaAckRequestSerializer.java new file mode 100644 index 0000000..2721518 --- /dev/null +++ b/src/com/isode/stroke/serializer/StanzaAckRequestSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StanzaAckRequest; +import com.isode.stroke.serializer.xml.XMLElement; + +class StanzaAckRequestSerializer extends GenericElementSerializer<StanzaAckRequest> { + + public StanzaAckRequestSerializer() { + super(StanzaAckRequest.class); + } + + public String serialize(Element element) { + return new XMLElement("r", "urn:xmpp:sm:2").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/StanzaAckSerializer.java b/src/com/isode/stroke/serializer/StanzaAckSerializer.java new file mode 100644 index 0000000..e8051a6 --- /dev/null +++ b/src/com/isode/stroke/serializer/StanzaAckSerializer.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StanzaAck; +import com.isode.stroke.serializer.xml.XMLElement; + +class StanzaAckSerializer extends GenericElementSerializer<StanzaAck> { + + public StanzaAckSerializer() { + super(StanzaAck.class); + } + + public String serialize(Element element) { + StanzaAck stanzaAck = (StanzaAck) element; + assert stanzaAck.isValid(); + XMLElement result = new XMLElement("a", "urn:xmpp:sm:2"); + result.setAttribute("h", Double.toString(stanzaAck.getHandledStanzasCount())); + return result.serialize(); + } +} diff --git a/src/com/isode/stroke/serializer/StanzaSerializer.java b/src/com/isode/stroke/serializer/StanzaSerializer.java new file mode 100644 index 0000000..950ccf7 --- /dev/null +++ b/src/com/isode/stroke/serializer/StanzaSerializer.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.Payload; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.serializer.xml.XMLElement; +import com.isode.stroke.serializer.xml.XMLRawTextNode; +import java.util.logging.Logger; + +public abstract class StanzaSerializer implements ElementSerializer { + + private final String tag_; + private final PayloadSerializerCollection payloadSerializers_; + private final Logger logger_ = Logger.getLogger(this.getClass().getName()); + + public StanzaSerializer(String tag, PayloadSerializerCollection payloadSerializers) { + payloadSerializers_ = payloadSerializers; + tag_ = tag; + } + + public String serialize(Element element) { + assert element != null; + assert payloadSerializers_ != null; + Stanza stanza = (Stanza) element; + XMLElement stanzaElement = new XMLElement(tag_); + if (stanza.getFrom() != null && stanza.getFrom().isValid()) { + stanzaElement.setAttribute("from", stanza.getFrom().toString()); + } + if (stanza.getTo() != null && stanza.getTo().isValid()) { + stanzaElement.setAttribute("to", stanza.getTo().toString()); + } + if (stanza.getID() != null && (stanza.getID().length()!=0)) { + stanzaElement.setAttribute("id", stanza.getID()); + } + setStanzaSpecificAttributes(stanza, stanzaElement); + + StringBuilder serializedPayloads = new StringBuilder(); + for (Payload payload : stanza.getPayloads()) { + PayloadSerializer serializer = payloadSerializers_.getPayloadSerializer(payload); + if (serializer != null) { + serializedPayloads.append(serializer.serialize(payload)); + } else { + /*TODO: port*/ + assert false; + //std::cerr << "Could not find serializer for " << typeid(*(payload.get())).name() << std::endl; + } + } + if (serializedPayloads.toString().length()!=0) { + stanzaElement.addNode(new XMLRawTextNode(serializedPayloads.toString())); + } + return stanzaElement.serialize(); + } + + public abstract void setStanzaSpecificAttributes(Element element, XMLElement xmlElement); +} diff --git a/src/com/isode/stroke/serializer/StartTLSFailureSerializer.java b/src/com/isode/stroke/serializer/StartTLSFailureSerializer.java new file mode 100644 index 0000000..2de5193 --- /dev/null +++ b/src/com/isode/stroke/serializer/StartTLSFailureSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StartTLSFailure; +import com.isode.stroke.serializer.xml.XMLElement; + +class StartTLSFailureSerializer extends GenericElementSerializer<StartTLSFailure> { + + public StartTLSFailureSerializer() { + super(StartTLSFailure.class); + } + + public String serialize(Element element) { + return new XMLElement("failure", "urn:ietf:params:xml:ns:xmpp-tls").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/StartTLSRequestSerializer.java b/src/com/isode/stroke/serializer/StartTLSRequestSerializer.java new file mode 100644 index 0000000..afa6b7b --- /dev/null +++ b/src/com/isode/stroke/serializer/StartTLSRequestSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StartTLSRequest; +import com.isode.stroke.serializer.xml.XMLElement; + +class StartTLSRequestSerializer extends GenericElementSerializer<StartTLSRequest> { + + public StartTLSRequestSerializer() { + super(StartTLSRequest.class); + } + + public String serialize(Element element) { + return new XMLElement("starttls", "urn:ietf:params:xml:ns:xmpp-tls").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/StreamManagementEnabledSerializer.java b/src/com/isode/stroke/serializer/StreamManagementEnabledSerializer.java new file mode 100644 index 0000000..84b127b --- /dev/null +++ b/src/com/isode/stroke/serializer/StreamManagementEnabledSerializer.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StreamManagementEnabled; +import com.isode.stroke.serializer.xml.XMLElement; + +class StreamManagementEnabledSerializer extends GenericElementSerializer<StreamManagementEnabled> { + + public StreamManagementEnabledSerializer() { + super(StreamManagementEnabled.class); + } + + public String serialize(Element el) { + StreamManagementEnabled e = (StreamManagementEnabled) el; + XMLElement element = new XMLElement("enabled", "urn:xmpp:sm:2"); + if (!e.getResumeID().isEmpty()) { + element.setAttribute("id", e.getResumeID()); + } + if (e.getResumeSupported()) { + element.setAttribute("resume", "true"); + } + return element.serialize(); + } +} diff --git a/src/com/isode/stroke/serializer/StreamManagementFailedSerializer.java b/src/com/isode/stroke/serializer/StreamManagementFailedSerializer.java new file mode 100644 index 0000000..7f4fb6b --- /dev/null +++ b/src/com/isode/stroke/serializer/StreamManagementFailedSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StreamManagementFailed; +import com.isode.stroke.serializer.xml.XMLElement; + +class StreamManagementFailedSerializer extends GenericElementSerializer<StreamManagementFailed> { + + public StreamManagementFailedSerializer() { + super(StreamManagementFailed.class); + } + + public String serialize(Element element) { + return new XMLElement("failed", "urn:xmpp:sm:2").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/StreamResumeSerializer.java b/src/com/isode/stroke/serializer/StreamResumeSerializer.java new file mode 100644 index 0000000..9e40f44 --- /dev/null +++ b/src/com/isode/stroke/serializer/StreamResumeSerializer.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StreamResume; +import com.isode.stroke.serializer.xml.XMLElement; + +class StreamResumeSerializer extends GenericElementSerializer<StreamResume> { + + public StreamResumeSerializer() { + super(StreamResume.class); + } + + public String serialize(Element el) { + StreamResume e = (StreamResume)el; + XMLElement element = new XMLElement("resume", "urn:xmpp:sm:2"); + element.setAttribute("previd", e.getResumeID()); + if (e.getHandledStanzasCount() != null) { + element.setAttribute("h", Long.toString(e.getHandledStanzasCount())); + } + return element.serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/StreamResumedSerializer.java b/src/com/isode/stroke/serializer/StreamResumedSerializer.java new file mode 100644 index 0000000..8fe6f53 --- /dev/null +++ b/src/com/isode/stroke/serializer/StreamResumedSerializer.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.StreamResumed; +import com.isode.stroke.serializer.xml.XMLElement; + +class StreamResumedSerializer extends GenericElementSerializer<StreamResumed> { + + public StreamResumedSerializer() { + super(StreamResumed.class); + } + + public String serialize(Element el) { + StreamResumed e = (StreamResumed)el; + XMLElement element = new XMLElement("resumed", "urn:xmpp:sm:2"); + element.setAttribute("previd", e.getResumeID()); + if (e.getHandledStanzasCount() != null) { + element.setAttribute("h", Long.toString(e.getHandledStanzasCount())); + } + return element.serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/TLSProceedSerializer.java b/src/com/isode/stroke/serializer/TLSProceedSerializer.java new file mode 100644 index 0000000..ca73456 --- /dev/null +++ b/src/com/isode/stroke/serializer/TLSProceedSerializer.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.TLSProceed; +import com.isode.stroke.serializer.xml.XMLElement; + +class TLSProceedSerializer extends GenericElementSerializer<TLSProceed>{ + + public TLSProceedSerializer() { + super(TLSProceed.class); + } + + public String serialize(Element element) { + return new XMLElement("proceed", "urn:ietf:params:xml:ns:xmpp-tls").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/XMPPSerializer.java b/src/com/isode/stroke/serializer/XMPPSerializer.java new file mode 100644 index 0000000..b51a4dc --- /dev/null +++ b/src/com/isode/stroke/serializer/XMPPSerializer.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer; + +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.elements.StreamType; +import java.util.Vector; + +public class XMPPSerializer { + + private final Vector<ElementSerializer> serializers_ = new Vector<ElementSerializer>(); + private final StreamType type_; + + public XMPPSerializer(PayloadSerializerCollection payloadSerializers, StreamType type) { + type_ = type; + serializers_.add(new PresenceSerializer(payloadSerializers)); + serializers_.add(new IQSerializer(payloadSerializers)); + serializers_.add(new MessageSerializer(payloadSerializers)); + serializers_.add(new CompressRequestSerializer()); + serializers_.add(new CompressFailureSerializer()); + serializers_.add(new AuthRequestSerializer()); + serializers_.add(new AuthFailureSerializer()); + serializers_.add(new AuthSuccessSerializer()); + serializers_.add(new AuthChallengeSerializer()); + serializers_.add(new AuthResponseSerializer()); + serializers_.add(new StartTLSRequestSerializer()); + serializers_.add(new StartTLSFailureSerializer()); + serializers_.add(new TLSProceedSerializer()); + //serializers_.add(new StreamFeaturesSerializer()); //TODO: Port + //serializers_.add(new StreamErrorSerializer()); //FIXME!!!: Port + serializers_.add(new EnableStreamManagementSerializer()); + serializers_.add(new StreamManagementEnabledSerializer()); + serializers_.add(new StreamManagementFailedSerializer()); + serializers_.add(new StreamResumeSerializer()); + serializers_.add(new StreamResumedSerializer()); + serializers_.add(new StanzaAckSerializer()); + serializers_.add(new StanzaAckRequestSerializer()); + //serializers_.add(new ComponentHandshakeSerializer()); + } + + public String serializeHeader(ProtocolHeader header) { + String result = "<?xml version=\"1.0\"?><stream:stream xmlns=\"" + getDefaultNamespace() + "\" xmlns:stream=\"http://etherx.jabber.org/streams\""; + if (header.getFrom().length() != 0) { + result += " from=\"" + header.getFrom() + "\""; + } + if (header.getTo().length() != 0) { + result += " to=\"" + header.getTo() + "\""; + } + if (header.getID().length() != 0) { + result += " id=\"" + header.getID() + "\""; + } + if (header.getVersion().length() != 0) { + result += " version=\"" + header.getVersion() + "\""; + } + result += ">"; + return result; + } + + public String serializeFooter() { + return "</stream:stream>"; + } + + public String getDefaultNamespace() { + switch (type_) { + case ClientStreamType: + return "jabber:client"; + case ServerStreamType: + return "jabber:server"; + case ComponentStreamType: + return "jabber:component:accept"; + } + assert false; + return ""; + } + + public String serializeElement(Element element) { + for (ElementSerializer serializer : serializers_) { + if (serializer.canSerialize(element)) { + return serializer.serialize(element); + } + } + throw new IllegalStateException("Trying to send an unknown element"); + //assert false; /* UNKNOWN ELEMENT */ + //return ""; + } +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/BodySerializer.java b/src/com/isode/stroke/serializer/payloadserializers/BodySerializer.java new file mode 100644 index 0000000..31037db --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/BodySerializer.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.Body; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLTextNode; + +/** + * Body to String. + */ +public class BodySerializer extends GenericPayloadSerializer<Body> { + + public BodySerializer() { + super(Body.class); + } + + @Override + protected String serializePayload(Body body) { + XMLTextNode textNode = new XMLTextNode(body.getText()); + return "<body>" + textNode.serialize() + "</body>"; + } +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/ErrorSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/ErrorSerializer.java new file mode 100644 index 0000000..9c34d53 --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/ErrorSerializer.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.ErrorPayload; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLTextNode; + +class ErrorSerializer extends GenericPayloadSerializer<ErrorPayload> { + + public ErrorSerializer() { + super(ErrorPayload.class); + } + + @Override + protected String serializePayload(ErrorPayload error) { + String result = "<error type=\""; + switch (error.getType()) { + case Continue: result += "continue"; break; + case Modify: result += "modify"; break; + case Auth: result += "auth"; break; + case Wait: result += "wait"; break; + default: result += "cancel"; break; + } + result += "\">"; + + String conditionElement; + switch (error.getCondition()) { + case BadRequest: conditionElement = "bad-request"; break; + case Conflict: conditionElement = "conflict"; break; + case FeatureNotImplemented: conditionElement = "feature-not-implemented"; break; + case Forbidden: conditionElement = "forbidden"; break; + case Gone: conditionElement = "gone"; break; + case InternalServerError: conditionElement = "internal-server-error"; break; + case ItemNotFound: conditionElement = "item-not-found"; break; + case JIDMalformed: conditionElement = "jid-malformed"; break; + case NotAcceptable: conditionElement = "not-acceptable"; break; + case NotAllowed: conditionElement = "not-allowed"; break; + case NotAuthorized: conditionElement = "not-authorized"; break; + case PaymentRequired: conditionElement = "payment-required"; break; + case RecipientUnavailable: conditionElement = "recipient-unavailable"; break; + case Redirect: conditionElement = "redirect"; break; + case RegistrationRequired: conditionElement = "registration-required"; break; + case RemoteServerNotFound: conditionElement = "remote-server-not-found"; break; + case RemoteServerTimeout: conditionElement = "remote-server-timeout"; break; + case ResourceConstraint: conditionElement = "resource-constraint"; break; + case ServiceUnavailable: conditionElement = "service-unavailable"; break; + case SubscriptionRequired: conditionElement = "subscription-required"; break; + case UnexpectedRequest: conditionElement = "unexpected-request"; break; + default: conditionElement = "undefined-condition"; break; + } + result += "<" + conditionElement + " xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\"/>"; + + if (error.getText().length() != 0) { + XMLTextNode textNode = new XMLTextNode(error.getText()); + result += "<text xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\">" + textNode.serialize() + "</text>"; + } + + result += "</error>"; + return result; + } + +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/FullPayloadSerializerCollection.java b/src/com/isode/stroke/serializer/payloadserializers/FullPayloadSerializerCollection.java new file mode 100644 index 0000000..52de35b --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/FullPayloadSerializerCollection.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.serializer.PayloadSerializerCollection; + +public class FullPayloadSerializerCollection extends PayloadSerializerCollection { + + public FullPayloadSerializerCollection() { + /*FIXME: Implement what's needed. */ + //addSerializer(new IBBSerializer()); + addSerializer(new BodySerializer()); + //addSerializer(new SubjectSerializer()); + //addSerializer(new ChatStateSerializer()); + //addSerializer(new PrioritySerializer()); + addSerializer(new ErrorSerializer()); + addSerializer(new RosterSerializer()); + //addSerializer(new MUCPayloadSerializer()); + //addSerializer(new MUCUserPayloadSerializer()); + //addSerializer(new MUCOwnerPayloadSerializer(this)); + addSerializer(new SoftwareVersionSerializer()); + //addSerializer(new StatusSerializer()); + //addSerializer(new StatusShowSerializer()); + //addSerializer(new DiscoInfoSerializer()); + //addSerializer(new DiscoItemsSerializer()); + //addSerializer(new CapsInfoSerializer()); + addSerializer(new ResourceBindSerializer()); + addSerializer(new StartSessionSerializer()); + //addSerializer(new SecurityLabelSerializer()); + //addSerializer(new SecurityLabelsCatalogSerializer()); + //addSerializer(new StreamInitiationSerializer()); + //addSerializer(new BytestreamsSerializer()); + //addSerializer(new VCardSerializer()); + //addSerializer(new VCardUpdateSerializer()); + addSerializer(new RawXMLPayloadSerializer()); + //addSerializer(new StorageSerializer()); + //addSerializer(new DelaySerializer()); + //addSerializer(new FormSerializer()); + //addSerializer(new PrivateStorageSerializer(this)); + //addSerializer(new CommandSerializer()); + //addSerializer(new NicknameSerializer()); + addSerializer(new SearchPayloadSerializer()); + addSerializer(new LastSerializer()); + } + +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/LastSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/LastSerializer.java new file mode 100644 index 0000000..e78a724 --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/LastSerializer.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2011 Kevin Smith + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.Last; +import com.isode.stroke.serializer.GenericPayloadSerializer; + +public class LastSerializer extends GenericPayloadSerializer<Last> { + + public LastSerializer() { + super(Last.class); + } + + @Override + protected String serializePayload(Last last) { + return "<query xmlns='jabber:iq:last' seconds='" + Integer.toString(last.getSeconds()) + "'/>"; + } +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/RawXMLPayloadSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/RawXMLPayloadSerializer.java new file mode 100644 index 0000000..4128537 --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/RawXMLPayloadSerializer.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.RawXMLPayload; +import com.isode.stroke.serializer.GenericPayloadSerializer; + +class RawXMLPayloadSerializer extends GenericPayloadSerializer<RawXMLPayload> { + + public RawXMLPayloadSerializer() { + super(RawXMLPayloadSerializer.class); + } + + @Override + protected String serializePayload(RawXMLPayload payload) { + return payload.getRawXML(); + } + +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/ResourceBindSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/ResourceBindSerializer.java new file mode 100644 index 0000000..a33627b --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/ResourceBindSerializer.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.ResourceBind; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLElement; +import com.isode.stroke.serializer.xml.XMLTextNode; + +class ResourceBindSerializer extends GenericPayloadSerializer<ResourceBind> { + + public ResourceBindSerializer() { + super(ResourceBind.class); + } + + @Override + protected String serializePayload(ResourceBind resourceBind) { + XMLElement bindElement = new XMLElement("bind", "urn:ietf:params:xml:ns:xmpp-bind"); + if (resourceBind.getJID().isValid()) { + XMLElement jidNode = new XMLElement("jid"); + jidNode.addNode(new XMLTextNode(resourceBind.getJID().toString())); + bindElement.addNode(jidNode); + } + else if (resourceBind.getResource().length() != 0) { + XMLElement resourceNode = new XMLElement("resource"); + resourceNode.addNode(new XMLTextNode(resourceBind.getResource())); + bindElement.addNode(resourceNode); + } + return bindElement.serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/RosterSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/RosterSerializer.java new file mode 100644 index 0000000..08a4b8e --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/RosterSerializer.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.RosterItemPayload; +import com.isode.stroke.elements.RosterPayload; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLElement; +import com.isode.stroke.serializer.xml.XMLTextNode; + +/** + * Roster to string. + */ +public class RosterSerializer extends GenericPayloadSerializer<RosterPayload> { + + public RosterSerializer() { + super(RosterPayload.class); + } + + @Override + protected String serializePayload(RosterPayload roster) { + XMLElement queryElement = new XMLElement("query", "jabber:iq:roster"); + for (RosterItemPayload item : roster.getItems()) { + XMLElement itemElement = new XMLElement("item"); + itemElement.setAttribute("jid", item.getJID().toString()); + if (item.getName() != null) { + itemElement.setAttribute("name", item.getName()); + } + + if (item.getSubscription() != null) { + switch (item.getSubscription()) { + case To: itemElement.setAttribute("subscription", "to"); break; + case From: itemElement.setAttribute("subscription", "from"); break; + case Both: itemElement.setAttribute("subscription", "both"); break; + case Remove: itemElement.setAttribute("subscription", "remove"); break; + case None: itemElement.setAttribute("subscription", "none"); break; + } + } + + if (item.getSubscriptionRequested()) { + itemElement.setAttribute("ask", "subscribe"); + } + + for (String group : item.getGroups()) { + XMLElement groupElement = new XMLElement("group"); + groupElement.addNode(new XMLTextNode(group)); + itemElement.addNode(groupElement); + } + + queryElement.addNode(itemElement); + } + + return queryElement.serialize(); + + + + } +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/SearchPayloadSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/SearchPayloadSerializer.java new file mode 100644 index 0000000..6928c97 --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/SearchPayloadSerializer.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.SearchPayload; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLElement; +import com.isode.stroke.serializer.xml.XMLTextNode; + +/** + * SearchPayload to String. + */ +public class SearchPayloadSerializer extends GenericPayloadSerializer<SearchPayload> { + + public SearchPayloadSerializer() { + super(SearchPayload.class); + } + + @Override + protected String serializePayload(SearchPayload searchPayload) { + XMLElement searchElement = new XMLElement("query", "jabber:iq:search"); + + if (searchPayload.getInstructions() != null) { + searchElement.addNode(new XMLElement("instructions", "", searchPayload.getInstructions())); + } + + if (searchPayload.getNick() != null) { + searchElement.addNode(new XMLElement("nick", "", searchPayload.getNick())); + } + + if (searchPayload.getFirst() != null) { + searchElement.addNode(new XMLElement("first", "", searchPayload.getFirst())); + } + + if (searchPayload.getLast() != null) { + searchElement.addNode(new XMLElement("last", "", searchPayload.getLast())); + } + + if (searchPayload.getEMail() != null) { + searchElement.addNode(new XMLElement("email", "", searchPayload.getEMail())); + } + + for (SearchPayload.Item item : searchPayload.getItems()) { + XMLElement itemElement = new XMLElement("item"); + itemElement.setAttribute("jid", item.jid.toString()); + itemElement.addNode(new XMLElement("first", "", item.first)); + itemElement.addNode(new XMLElement("last", "", item.last)); + itemElement.addNode(new XMLElement("nick", "", item.nick)); + itemElement.addNode(new XMLElement("email", "", item.email)); + + searchElement.addNode(itemElement); + } + + //if (Form::ref form = searchPayload->getForm()) { + // searchElement.addNode(boost::shared_ptr<XMLRawTextNode>(new XMLRawTextNode(FormSerializer().serialize(form)))); + //} /* Not ported yet. When the time comes, look at Swiften to check if it's changed. It will have. */ + + return searchElement.serialize(); + } +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/SoftwareVersionSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/SoftwareVersionSerializer.java new file mode 100644 index 0000000..cb2b653 --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/SoftwareVersionSerializer.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * All rights reserved. + */ +/* + * Copyright (c) 2010 Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.Version; +import com.isode.stroke.serializer.GenericPayloadSerializer; + +public class SoftwareVersionSerializer extends GenericPayloadSerializer<Version>{ + + public SoftwareVersionSerializer() { + super(Version.class); + } + + @Override + protected String serializePayload(Version version) { + StringBuilder result = new StringBuilder(); + result.append("<query xmlns=\"jabber:iq:version\">"); + if (version.getName() != null && version.getName().length() > 0) { + result.append("<name>").append(version.getName()).append("</name>"); + } + if (version.getVersion() != null && version.getVersion().length() > 0) { + result.append("<version>").append(version.getVersion()).append("</version>"); + } + if (version.getOS() != null && version.getOS().length() > 0) { + result.append("<os>").append(version.getOS()).append("</os>"); + } + result.append("</query>"); + return result.toString(); + + } + +} diff --git a/src/com/isode/stroke/serializer/payloadserializers/StartSessionSerializer.java b/src/com/isode/stroke/serializer/payloadserializers/StartSessionSerializer.java new file mode 100644 index 0000000..8d36b8c --- /dev/null +++ b/src/com/isode/stroke/serializer/payloadserializers/StartSessionSerializer.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer.payloadserializers; + +import com.isode.stroke.elements.StartSession; +import com.isode.stroke.serializer.GenericPayloadSerializer; +import com.isode.stroke.serializer.xml.XMLElement; + +class StartSessionSerializer extends GenericPayloadSerializer<StartSession> { + + public StartSessionSerializer() { + super(StartSession.class); + } + + @Override + protected String serializePayload(StartSession payload) { + return new XMLElement("session", "urn:ietf:params:xml:ns:xmpp-session").serialize(); + } + +} diff --git a/src/com/isode/stroke/serializer/xml/XMLElement.java b/src/com/isode/stroke/serializer/xml/XMLElement.java new file mode 100644 index 0000000..909f277 --- /dev/null +++ b/src/com/isode/stroke/serializer/xml/XMLElement.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.xml; + +import java.util.HashMap; +import java.util.Vector; + +public class XMLElement implements XMLNode { + + private final String tag_; + private final HashMap<String, String> attributes_ = new HashMap<String, String>(); + private final Vector<XMLNode> childNodes_ = new Vector<XMLNode>(); + + public XMLElement(String tag) { + this(tag, ""); + } + + public XMLElement(String tag, String xmlns) { + tag_ = tag; + if (xmlns.length()!=0) { + setAttribute("xmlns", xmlns); + } + } + + public XMLElement(String tag, String xmlns, String text) { + this(tag, xmlns); + if (text.length() > 0) { + addNode(new XMLTextNode(text)); + } + } + + public String serialize() { + String result = ""; + result += "<" + tag_; + for (String key : attributes_.keySet()) { + result += " " + key + "=\"" + attributes_.get(key) + "\""; + } + + if (childNodes_.size() > 0) { + result += ">"; + for (XMLNode node : childNodes_) { + result += node.serialize(); + } + result += "</" + tag_ + ">"; + } else { + result += "/>"; + } + return result; + } + + public void setAttribute(String attribute, String value) { + String escapedValue = value; + escapedValue.replaceAll("&", "&"); + escapedValue.replaceAll("<", "<"); + escapedValue.replaceAll(">", ">"); + escapedValue.replaceAll("'", "'"); + escapedValue.replaceAll("\"", """); + attributes_.put(attribute, escapedValue); + } + + public void addNode(XMLNode node) { + childNodes_.add(node); + } +} diff --git a/src/com/isode/stroke/serializer/xml/XMLNode.java b/src/com/isode/stroke/serializer/xml/XMLNode.java new file mode 100644 index 0000000..0b64f85 --- /dev/null +++ b/src/com/isode/stroke/serializer/xml/XMLNode.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer.xml; + +public interface XMLNode { + public String serialize(); +} diff --git a/src/com/isode/stroke/serializer/xml/XMLRawTextNode.java b/src/com/isode/stroke/serializer/xml/XMLRawTextNode.java new file mode 100644 index 0000000..ad726bc --- /dev/null +++ b/src/com/isode/stroke/serializer/xml/XMLRawTextNode.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.serializer.xml; + +public class XMLRawTextNode implements XMLNode { + private final String text_; + + public XMLRawTextNode(String text) { + text_ = text; + } + + public String serialize() { + return text_; + } +} diff --git a/src/com/isode/stroke/serializer/xml/XMLTextNode.java b/src/com/isode/stroke/serializer/xml/XMLTextNode.java new file mode 100644 index 0000000..af11c27 --- /dev/null +++ b/src/com/isode/stroke/serializer/xml/XMLTextNode.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.serializer.xml; + +public class XMLTextNode implements XMLNode { + + private final String text_; + + public XMLTextNode(String text) { + text_ = text; + text_.replaceAll("&", "&"); // Should come first + text_.replaceAll("<", "<"); + text_.replaceAll(">", ">"); + } + + public String serialize() { + return text_; + } +} diff --git a/src/com/isode/stroke/session/BasicSessionStream.java b/src/com/isode/stroke/session/BasicSessionStream.java new file mode 100644 index 0000000..c7c98cf --- /dev/null +++ b/src/com/isode/stroke/session/BasicSessionStream.java @@ -0,0 +1,252 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.session; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.elements.StreamType; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.network.Connection; +import com.isode.stroke.network.TimerFactory; +import com.isode.stroke.parser.PayloadParserFactoryCollection; +import com.isode.stroke.serializer.PayloadSerializerCollection; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.streamstack.CompressionLayer; +import com.isode.stroke.streamstack.ConnectionLayer; +import com.isode.stroke.streamstack.StreamStack; +import com.isode.stroke.streamstack.TLSLayer; +import com.isode.stroke.streamstack.WhitespacePingLayer; +import com.isode.stroke.tls.TLSContextFactory; +import com.isode.stroke.streamstack.XMPPLayer; +import com.isode.stroke.tls.Certificate; +import com.isode.stroke.tls.CertificateVerificationError; + +public class BasicSessionStream extends SessionStream { + + public BasicSessionStream( + StreamType streamType, + Connection connection, + PayloadParserFactoryCollection payloadParserFactories, + PayloadSerializerCollection payloadSerializers, + TLSContextFactory tlsContextFactory, + TimerFactory timerFactory, + EventLoop eventLoop) { + available = false; + this.connection = connection; + this.payloadParserFactories = payloadParserFactories; + this.payloadSerializers = payloadSerializers; + this.tlsContextFactory = tlsContextFactory; + this.timerFactory = timerFactory; + if (timerFactory == null) { + throw new IllegalStateException(); //FIXME: remove conditional, debugging only. + } + this.streamType = streamType; + this.compressionLayer = null; + this.tlsLayer = null; + this.whitespacePingLayer = null; + + xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, streamType, eventLoop); + xmppLayer.onStreamStart.connect(new Slot1<ProtocolHeader>() { + + public void call(ProtocolHeader p1) { + handleStreamStartReceived(p1); + } + }); + xmppLayer.onElement.connect(new Slot1<Element>() { + + public void call(Element p1) { + handleElementReceived(p1); + } + }); + xmppLayer.onError.connect(new Slot() { + + public void call() { + handleXMPPError(); + } + }); + xmppLayer.onDataRead.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + handleDataRead(p1); + } + }); + xmppLayer.onWriteData.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + handleDataWritten(p1); + } + }); + + connection.onDisconnected.connect(new Slot1<Connection.Error>() { + + public void call(Connection.Error p1) { + handleConnectionFinished(p1); + } + }); + connectionLayer = new ConnectionLayer(connection); + + streamStack = new StreamStack(xmppLayer, connectionLayer); + + available = true; + + } + + public void writeHeader(ProtocolHeader header) { + assert available; + xmppLayer.writeHeader(header); + } + + public void writeElement(Element element) { + assert available; + xmppLayer.writeElement(element); + } + + public void writeFooter() { + assert available; + xmppLayer.writeFooter(); + } + + public void writeData(String data) { + assert available; + xmppLayer.writeData(data); + } + + public void close() { + connection.disconnect(); + } + + public boolean isOpen() { + return available; + } + + public boolean supportsTLSEncryption() { + return tlsContextFactory != null && tlsContextFactory.canCreate(); + } + + public void addTLSEncryption() { + assert available; + tlsLayer = new TLSLayer(tlsContextFactory); + if (hasTLSCertificate() && !tlsLayer.setClientCertificate(getTLSCertificate())) { + onClosed.emit(new Error(Error.Type.InvalidTLSCertificateError)); + } else { + streamStack.addLayer(tlsLayer); + tlsLayer.onError.connect(new Slot() { + + public void call() { + handleTLSError(); + } + }); + tlsLayer.onConnected.connect(new Slot() { + + public void call() { + handleTLSConnected(); + } + }); + tlsLayer.connect(); + } + } + + public boolean isTLSEncrypted() { + return tlsLayer != null; + } + + public Certificate getPeerCertificate() { + return tlsLayer.getPeerCertificate(); + } + + public CertificateVerificationError getPeerCertificateVerificationError() { + return tlsLayer.getPeerCertificateVerificationError(); + } + + public ByteArray getTLSFinishMessage() { + return tlsLayer.getContext().getFinishMessage(); + } + + public void addZLibCompression() { + compressionLayer = new CompressionLayer(); + streamStack.addLayer(compressionLayer); + } + + public void setWhitespacePingEnabled(boolean enabled) { + if (enabled) { + if (whitespacePingLayer == null) { + whitespacePingLayer = new WhitespacePingLayer(timerFactory); + streamStack.addLayer(whitespacePingLayer); + } + whitespacePingLayer.setActive(); + } + else if (whitespacePingLayer != null) { + whitespacePingLayer.setInactive(); + } + } + + public void resetXMPPParser() { + xmppLayer.resetParser(); + } + + private void handleStreamStartReceived(ProtocolHeader header) { + onStreamStartReceived.emit(header); + } + + private void handleElementReceived(Element element) { + onElementReceived.emit(element); + } + + private void handleXMPPError() { + available = false; + onClosed.emit(new Error(Error.Type.ParseError)); + } + + private void handleTLSConnected() { + onTLSEncrypted.emit(); + } + + private void handleTLSError() { + available = false; + onClosed.emit(new Error(Error.Type.TLSError)); + } + + private void handleConnectionFinished(Connection.Error error) { + available = false; + if (Connection.Error.ReadError.equals(error)) { + onClosed.emit(new Error(Error.Type.ConnectionReadError)); + } + else if (error != null) { + onClosed.emit(new Error(Error.Type.ConnectionWriteError)); + } + else { + onClosed.emit(null); + } + } + + private void handleDataRead(ByteArray data) { + onDataRead.emit(data.toString()); + } + + private void handleDataWritten(ByteArray data) { + onDataWritten.emit(data.toString()); + } + private boolean available; + private Connection connection; + private PayloadParserFactoryCollection payloadParserFactories; + private PayloadSerializerCollection payloadSerializers; + private TLSContextFactory tlsContextFactory; + private TimerFactory timerFactory; + private StreamType streamType; + private XMPPLayer xmppLayer; + private ConnectionLayer connectionLayer; + private CompressionLayer compressionLayer; + private TLSLayer tlsLayer; + private WhitespacePingLayer whitespacePingLayer; + private StreamStack streamStack; + +} diff --git a/src/com/isode/stroke/session/Session.java b/src/com/isode/stroke/session/Session.java new file mode 100644 index 0000000..79132e4 --- /dev/null +++ b/src/com/isode/stroke/session/Session.java @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.session; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.elements.StreamType; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.jid.JID; +import com.isode.stroke.network.Connection; +import com.isode.stroke.parser.PayloadParserFactoryCollection; +import com.isode.stroke.serializer.PayloadSerializerCollection; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.signals.Slot; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.streamstack.ConnectionLayer; +import com.isode.stroke.streamstack.StreamStack; +import com.isode.stroke.streamstack.XMPPLayer; + +public abstract class Session { + + public enum SessionError { + + ConnectionReadError, + ConnectionWriteError, + XMLError, + AuthenticationFailedError, + NoSupportedAuthMechanismsError, + UnexpectedElementError, + ResourceBindError, + SessionStartError, + TLSError, + ClientCertificateLoadError, + ClientCertificateError + }; + + public Session( + final Connection connection, + final PayloadParserFactoryCollection payloadParserFactories, + final PayloadSerializerCollection payloadSerializers, + final EventLoop eventLoop) { + this.connection = connection; + this.eventLoop = eventLoop; + this.payloadParserFactories = payloadParserFactories; + this.payloadSerializers = payloadSerializers; + finishing = false; + } + + + public void startSession() { + initializeStreamStack(); + handleSessionStarted(); + } + + public void finishSession() { + finishing = true; + connection.disconnect(); + handleSessionFinished(null); + finishing = false; + onSessionFinished.emit(null); + } + + public void sendElement(Element stanza) { + xmppLayer.writeElement(stanza); + } + + public JID getLocalJID() { + return localJID; + } + + public JID getRemoteJID() { + return remoteJID; + } + public final Signal1<Element> onElementReceived = new Signal1<Element>(); + public final Signal1<SessionError> onSessionFinished = new Signal1<SessionError>(); + public final Signal1<ByteArray> onDataWritten = new Signal1<ByteArray>(); + public final Signal1<ByteArray> onDataRead = new Signal1<ByteArray>(); + + protected void setRemoteJID(JID j) { + remoteJID = j; + } + + protected void setLocalJID(JID j) { + localJID = j; + } + + protected void finishSession(SessionError error) { + finishing = true; + connection.disconnect(); + handleSessionFinished(error); + finishing = false; + onSessionFinished.emit(error); + } + + protected void handleSessionStarted() { + } + + protected void handleSessionFinished(SessionError error) { + } + + protected abstract void handleElement(Element element); + + protected abstract void handleStreamStart(ProtocolHeader header); + + protected void initializeStreamStack() { + xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, StreamType.ClientStreamType, eventLoop); + xmppLayer.onStreamStart.connect(new Slot1<ProtocolHeader>() { + + public void call(ProtocolHeader header) { + handleStreamStart(header); + } + }); + xmppLayer.onElement.connect(new Slot1<Element>() { + + public void call(Element p1) { + handleElement(p1); + } + }); + xmppLayer.onError.connect(new Slot() { + + public void call() { + finishSession(SessionError.XMLError); + } + }); + xmppLayer.onDataRead.connect(onDataRead); + xmppLayer.onWriteData.connect(onDataWritten); + connection.onDisconnected.connect(new Slot1<Connection.Error>() { + + public void call(Connection.Error p1) { + handleDisconnected(p1); + } + }); + connectionLayer = new ConnectionLayer(connection); + streamStack = new StreamStack(xmppLayer, connectionLayer); + } + + public XMPPLayer getXMPPLayer() { + return xmppLayer; + + + } + + public StreamStack getStreamStack() { + return streamStack; + + + } + + /*void setFinished();*/ /* This seems to be unused in Swiften*/ + + private void handleDisconnected(Connection.Error connectionError) { + if (connectionError != null) { + switch (connectionError) { + case ReadError: + finishSession(SessionError.ConnectionReadError); + break; + case WriteError: + finishSession(SessionError.ConnectionWriteError); + break; + } + } else { + finishSession(); + } + } + private JID localJID; + private JID remoteJID; + private Connection connection; + private PayloadParserFactoryCollection payloadParserFactories; + private PayloadSerializerCollection payloadSerializers; + private XMPPLayer xmppLayer; + private ConnectionLayer connectionLayer; + private StreamStack streamStack; + private boolean finishing; + private final EventLoop eventLoop; +} diff --git a/src/com/isode/stroke/session/SessionStream.java b/src/com/isode/stroke/session/SessionStream.java new file mode 100644 index 0000000..c70622b --- /dev/null +++ b/src/com/isode/stroke/session/SessionStream.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.session; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.tls.Certificate; +import com.isode.stroke.tls.CertificateVerificationError; +import com.isode.stroke.tls.PKCS12Certificate; + +public abstract class SessionStream { + + public static class Error implements com.isode.stroke.base.Error { + + public enum Type { + + ParseError, + TLSError, + InvalidTLSCertificateError, + ConnectionReadError, + ConnectionWriteError + }; + + public Error(Type type) { + this.type = type; + } + public final Type type; + }; + + public abstract void close(); + + public abstract boolean isOpen(); + + public abstract void writeHeader(ProtocolHeader header); + + public abstract void writeFooter(); + + public abstract void writeElement(Element element); + + public abstract void writeData(String data); + + public abstract void addZLibCompression(); + + public abstract boolean supportsTLSEncryption(); + + public abstract void addTLSEncryption(); + + public abstract boolean isTLSEncrypted(); + + public abstract void setWhitespacePingEnabled(boolean enabled); + + public abstract void resetXMPPParser(); + + public void setTLSCertificate(PKCS12Certificate cert) { + certificate = cert; + } + + public boolean hasTLSCertificate() { + return certificate != null && !certificate.isNull(); + } + + public abstract Certificate getPeerCertificate(); + + public abstract CertificateVerificationError getPeerCertificateVerificationError(); + + public abstract ByteArray getTLSFinishMessage(); + + public final Signal1<ProtocolHeader> onStreamStartReceived = new Signal1<ProtocolHeader>(); + public final Signal1<Element> onElementReceived = new Signal1<Element>(); + public final Signal1<Error> onClosed = new Signal1<Error>(); + public final Signal onTLSEncrypted = new Signal(); + public final Signal1<String> onDataRead = new Signal1<String>(); + public final Signal1<String> onDataWritten = new Signal1<String>(); + protected PKCS12Certificate getTLSCertificate() { + return certificate; + } + private PKCS12Certificate certificate; +} diff --git a/src/com/isode/stroke/session/SessionTracer.java b/src/com/isode/stroke/session/SessionTracer.java new file mode 100644 index 0000000..93c51a8 --- /dev/null +++ b/src/com/isode/stroke/session/SessionTracer.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.session; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.signals.Slot1; + +public class SessionTracer { + + public SessionTracer(Session session) { + this.session = session; + session.onDataRead.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + printData('<', p1); + } + }); + + session.onDataWritten.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + printData('>', p1); + } + }); + } + + private void printData(char direction, ByteArray data) { + System.err.print("" + direction + direction + " " + session.getLocalJID().toString() + " "); + for (int i = 0; i < 72 - session.getLocalJID().toString().length() - session.getRemoteJID().toString().length(); ++i) { + System.err.print(direction); + } + System.err.println(" " + session.getRemoteJID().toString() + " " + direction + direction); + System.err.println(data); + } + private Session session; +}
\ No newline at end of file diff --git a/src/com/isode/stroke/signals/Signal.java b/src/com/isode/stroke/signals/Signal.java new file mode 100644 index 0000000..cfa8665 --- /dev/null +++ b/src/com/isode/stroke/signals/Signal.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.signals; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * An approximation of the boost::signals system, although a little more warty. + */ +public class Signal { + + private final Map<SignalConnection, Slot> binds_ = Collections.synchronizedMap(new HashMap<SignalConnection, Slot>()); + + public SignalConnection connect(Slot bind) { + final SignalConnection connection = new SignalConnection(); + binds_.put(connection, bind); + connection.onDestroyed.connectWithoutReturn(new Slot() { + + public void call() { + binds_.remove(connection); + } + }); + return connection; + } + + public SignalConnection connect(final Signal target) { + return connect(new Slot() { + public void call() { + target.emit(); + } + }); + } + + void connectWithoutReturn(Slot bind) { + binds_.put(null, bind); + } + + public void emit() { + ArrayList<Slot> binds = new ArrayList<Slot>(); + binds.addAll(binds_.values()); + for (Slot bind : binds) { + bind.call(); + } + } + + public void disconnectAll() { + binds_.clear(); + } +} diff --git a/src/com/isode/stroke/signals/Signal1.java b/src/com/isode/stroke/signals/Signal1.java new file mode 100644 index 0000000..c799d4c --- /dev/null +++ b/src/com/isode/stroke/signals/Signal1.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * An approximation of the boost::signals system, although a little more warty. + */ +public class Signal1<T1> { + private final Map<SignalConnection, Slot1<T1> > binds_ = Collections.synchronizedMap(new HashMap<SignalConnection, Slot1<T1> >()); + public SignalConnection connect(Slot1<T1> bind) { + final SignalConnection connection = new SignalConnection(); + binds_.put(connection, bind); + connection.onDestroyed.connect(new Slot() { + public void call() { + binds_.remove(connection); + } + }); + return connection; + } + + public void emit(T1 p1) { + ArrayList<Slot1<T1>> binds = new ArrayList<Slot1<T1>>(); + binds.addAll(binds_.values()); + for (Slot1<T1> bind : binds) { + bind.call(p1); + } + } + + public SignalConnection connect(final Signal1<T1> target) { + return connect(new Slot1<T1>() { + public void call(T1 p1) { + target.emit(p1); + } + }); + } + + public void disconnectAll() { + binds_.clear(); + } +} diff --git a/src/com/isode/stroke/signals/Signal2.java b/src/com/isode/stroke/signals/Signal2.java new file mode 100644 index 0000000..fa3c4b5 --- /dev/null +++ b/src/com/isode/stroke/signals/Signal2.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * An approximation of the boost::signals system, although a little more warty. + */ +public class Signal2<T1, T2> { + private final Map<SignalConnection, Slot2<T1, T2> > binds_ = Collections.synchronizedMap(new HashMap<SignalConnection, Slot2<T1, T2> >()); + public SignalConnection connect(Slot2<T1, T2> bind) { + final SignalConnection connection = new SignalConnection(); + binds_.put(connection, bind); + connection.onDestroyed.connect(new Slot() { + public void call() { + binds_.remove(connection); + } + }); + return connection; + } + + public void emit(T1 p1, T2 p2) { + ArrayList<Slot2<T1,T2>> binds = new ArrayList<Slot2<T1, T2>>(); + binds.addAll(binds_.values()); + for (Slot2<T1, T2> bind : binds) { + bind.call(p1, p2); + } + } + + public void disconnectAll() { + binds_.clear(); + } +} diff --git a/src/com/isode/stroke/signals/SignalConnection.java b/src/com/isode/stroke/signals/SignalConnection.java new file mode 100644 index 0000000..452c80b --- /dev/null +++ b/src/com/isode/stroke/signals/SignalConnection.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + + +public class SignalConnection { + public final Signal onDestroyed = new Signal(); + + public void disconnect() { + onDestroyed.emit(); + } +} diff --git a/src/com/isode/stroke/signals/Slot.java b/src/com/isode/stroke/signals/Slot.java new file mode 100644 index 0000000..35b8c70 --- /dev/null +++ b/src/com/isode/stroke/signals/Slot.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + +/** + * Bind class for connecting to a signal. + */ +public interface Slot { + void call(); +} diff --git a/src/com/isode/stroke/signals/Slot1.java b/src/com/isode/stroke/signals/Slot1.java new file mode 100644 index 0000000..a8f0179 --- /dev/null +++ b/src/com/isode/stroke/signals/Slot1.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + +/** + * Bind class for connecting to a signal. + */ +public interface Slot1<T1> { + void call(T1 p1); +} diff --git a/src/com/isode/stroke/signals/Slot2.java b/src/com/isode/stroke/signals/Slot2.java new file mode 100644 index 0000000..b3b9330 --- /dev/null +++ b/src/com/isode/stroke/signals/Slot2.java @@ -0,0 +1,13 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.signals; + +/** + * Bind class for connecting to a signal. + */ +public interface Slot2<T1, T2> { + void call(T1 p1, T2 p2); +} diff --git a/src/com/isode/stroke/streammanagement/StanzaAckRequester.java b/src/com/isode/stroke/streammanagement/StanzaAckRequester.java new file mode 100644 index 0000000..d698e89 --- /dev/null +++ b/src/com/isode/stroke/streammanagement/StanzaAckRequester.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.streammanagement; + +import com.isode.stroke.elements.Message; +import com.isode.stroke.elements.Stanza; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; +import java.util.ArrayList; +import java.util.List; + +public class StanzaAckRequester { + + static final long MAX_HANDLED_STANZA_COUNT = Long.parseLong("4294967295"); //boost::numeric_cast<unsigned int>((1ULL<<32) - 1); + + public StanzaAckRequester() { + + } + + public void handleStanzaSent(Stanza stanza) { + unackedStanzas.add(stanza); + if (stanza instanceof Message) { + onRequestAck.emit(); + } + } + + public void handleAckReceived(long handledStanzasCount) { + long i = lastHandledStanzasCount; + while (i != handledStanzasCount) { + if (unackedStanzas.isEmpty()) { + //std::cerr << "Warning: Server acked more stanzas than we sent" << std::endl; + break; + } + Stanza ackedStanza = unackedStanzas.get(0); + unackedStanzas.remove(0); + onStanzaAcked.emit(ackedStanza); + i = (i == MAX_HANDLED_STANZA_COUNT ? 0 : i + 1); + } + lastHandledStanzasCount = handledStanzasCount; + } + + public Signal onRequestAck = new Signal(); + + public Signal1<Stanza> onStanzaAcked = new Signal1<Stanza>(); + + private long lastHandledStanzasCount; + + private List<Stanza> unackedStanzas = new ArrayList<Stanza>(); +} diff --git a/src/com/isode/stroke/streammanagement/StanzaAckResponder.java b/src/com/isode/stroke/streammanagement/StanzaAckResponder.java new file mode 100644 index 0000000..e0de87a --- /dev/null +++ b/src/com/isode/stroke/streammanagement/StanzaAckResponder.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.streammanagement; + +import com.isode.stroke.signals.Signal1; + +public class StanzaAckResponder { + + static final long MAX_HANDLED_STANZA_COUNT = Long.parseLong("4294967295"); //boost::numeric_cast<unsigned int>((1ULL<<32) - 1); + + public StanzaAckResponder() { + } + + public void handleStanzaReceived() { + handledStanzasCount = (handledStanzasCount == MAX_HANDLED_STANZA_COUNT ? 0 : handledStanzasCount + 1); + } + + public void handleAckRequestReceived() { + onAck.emit(handledStanzasCount); + } + public Signal1<Long> onAck = new Signal1<Long>(); + private long handledStanzasCount = 0; +} diff --git a/src/com/isode/stroke/streamstack/CompressionLayer.java b/src/com/isode/stroke/streamstack/CompressionLayer.java new file mode 100644 index 0000000..fae8263 --- /dev/null +++ b/src/com/isode/stroke/streamstack/CompressionLayer.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.compress.ZLibCompressor; +import com.isode.stroke.compress.ZLibDecompressor; +import com.isode.stroke.compress.ZLibException; +import com.isode.stroke.signals.Signal; + +public class CompressionLayer extends StreamLayer { + + public void writeData(ByteArray data) { + try { + writeDataToChildLayer(compressor_.process(data)); + } + catch (ZLibException e) { + onError.emit(); + } + } + + public void handleDataRead(ByteArray data) { + try { + writeDataToParentLayer(decompressor_.process(data)); + } + catch (ZLibException e) { + onError.emit(); + } + } + + public Signal onError = new Signal(); + + private ZLibCompressor compressor_ = new ZLibCompressor(); + private ZLibDecompressor decompressor_ = new ZLibDecompressor(); + +} diff --git a/src/com/isode/stroke/streamstack/ConnectionLayer.java b/src/com/isode/stroke/streamstack/ConnectionLayer.java new file mode 100644 index 0000000..525da50 --- /dev/null +++ b/src/com/isode/stroke/streamstack/ConnectionLayer.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.network.Connection; +import com.isode.stroke.signals.Signal1; +import com.isode.stroke.signals.Slot1; + +public class ConnectionLayer implements LowLayer { + + public ConnectionLayer(Connection connection) { + this.connection = connection; + connection.onDataRead.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + writeDataToParentLayer(p1); + } + }); + } + + public void writeData(ByteArray data) { + connection.write(data); + } + + private Connection connection; + + /* Work around multiple inheritance workaround again */ + StreamLayer fakeStreamLayer_ = new StreamLayer() { + + public void writeData(ByteArray data) { + connection.write(data); + } + + public void handleDataRead(ByteArray data) { + throw new UnsupportedOperationException("Not supported yet."); + } + }; + + public HighLayer getParentLayer() { + return fakeStreamLayer_.getParentLayer(); + } + + public void setParentLayer(HighLayer parentLayer) { + fakeStreamLayer_.setParentLayer(parentLayer); + } + + public void writeDataToParentLayer(ByteArray data) { + fakeStreamLayer_.writeDataToParentLayer(data); + } +} diff --git a/src/com/isode/stroke/streamstack/HighLayer.java b/src/com/isode/stroke/streamstack/HighLayer.java new file mode 100644 index 0000000..9ef37d1 --- /dev/null +++ b/src/com/isode/stroke/streamstack/HighLayer.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; + +/** + * Because of the lack of multiple inheritance in Java, this has to be done + * slightly differently from Swiften. What happens is that the methods in Swiften + * are provided abstract here, and implemented in the StreamLayer instead. + */ +public interface HighLayer { + + void handleDataRead(ByteArray data); + + + /* Should be protected */ + LowLayer getChildLayer(); + + void setChildLayer(LowLayer childLayer); + + void writeDataToChildLayer(ByteArray data); + +} diff --git a/src/com/isode/stroke/streamstack/LowLayer.java b/src/com/isode/stroke/streamstack/LowLayer.java new file mode 100644 index 0000000..fa31075 --- /dev/null +++ b/src/com/isode/stroke/streamstack/LowLayer.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; + +/** + * Because of the lack of multiple inheritance in Java, this has to be done + * slightly differently from Swiften. What happens is that the methods in Swiften + * are provided abstract here, and implemented in the StreamLayer instead. + */ +public interface LowLayer { + + void writeData(ByteArray data); + + /* Should be protected */ + + HighLayer getParentLayer(); + + void setParentLayer(HighLayer parentLayer); + + void writeDataToParentLayer(ByteArray data); +} diff --git a/src/com/isode/stroke/streamstack/StreamLayer.java b/src/com/isode/stroke/streamstack/StreamLayer.java new file mode 100644 index 0000000..c6d8f50 --- /dev/null +++ b/src/com/isode/stroke/streamstack/StreamLayer.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ + +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; + +/** + * Because of the lack of multiple inheritance in Java, this implements + * the abstract methods that should have been implemented in + * LowLayer and HighLayer. + */ +public abstract class StreamLayer implements LowLayer, HighLayer { + + public HighLayer getParentLayer() { + return parentLayer; + } + + public void setParentLayer(final HighLayer parentLayer) { + this.parentLayer = parentLayer; + } + + public void writeDataToParentLayer(final ByteArray data) { + assert parentLayer != null; + parentLayer.handleDataRead(data); + } + + public LowLayer getChildLayer() { + return childLayer; + } + + public void setChildLayer(final LowLayer childLayer) { + this.childLayer = childLayer; + } + + public void writeDataToChildLayer(final ByteArray data) { + assert childLayer != null; + childLayer.writeData(data); + } + + private HighLayer parentLayer; + private LowLayer childLayer; +} diff --git a/src/com/isode/stroke/streamstack/StreamStack.java b/src/com/isode/stroke/streamstack/StreamStack.java new file mode 100644 index 0000000..f539624 --- /dev/null +++ b/src/com/isode/stroke/streamstack/StreamStack.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import java.util.ArrayList; +import java.util.List; + +public class StreamStack { + + public StreamStack(XMPPLayer xmppLayer, LowLayer physicalLayer) { + xmppLayer_ = xmppLayer; + physicalLayer_ = physicalLayer; + physicalLayer_.setParentLayer(xmppLayer_); + xmppLayer.setChildLayer(physicalLayer_); + } + + public void addLayer(final StreamLayer newLayer) { + final LowLayer lowLayer = (layers_.isEmpty() ? physicalLayer_ : layers_.get(layers_.size() - 1)); + + xmppLayer_.setChildLayer(newLayer); + newLayer.setParentLayer(xmppLayer_); + + lowLayer.setParentLayer(newLayer); + newLayer.setChildLayer(lowLayer); + + layers_.add(newLayer); + } + + public XMPPLayer getXMPPLayer() { + return xmppLayer_; + } + + public Object getLayer(Class layerClass) { + for (StreamLayer layer : layers_) { + if (layerClass.isAssignableFrom(layer.getClass())) { + return layer; + } + } + return null; + } + + private XMPPLayer xmppLayer_; + private LowLayer physicalLayer_; + private List<StreamLayer> layers_ = new ArrayList<StreamLayer>(); +} diff --git a/src/com/isode/stroke/streamstack/TLSLayer.java b/src/com/isode/stroke/streamstack/TLSLayer.java new file mode 100644 index 0000000..ecf908d --- /dev/null +++ b/src/com/isode/stroke/streamstack/TLSLayer.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Slot1; +import com.isode.stroke.tls.Certificate; +import com.isode.stroke.tls.CertificateVerificationError; +import com.isode.stroke.tls.PKCS12Certificate; +import com.isode.stroke.tls.TLSContext; +import com.isode.stroke.tls.TLSContextFactory; + +public class TLSLayer extends StreamLayer { + + public TLSLayer(TLSContextFactory factory) { + context = factory.createTLSContext(); + context.onDataForNetwork.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + writeDataToChildLayer(p1); + } + }); + context.onDataForApplication.connect(new Slot1<ByteArray>() { + + public void call(ByteArray p1) { + writeDataToParentLayer(p1); + } + }); + context.onConnected.connect(onConnected); + context.onError.connect(onError); + } + + public void connect() { + context.connect(); + } + + public void writeData(ByteArray data) { + context.handleDataFromApplication(data); + } + + public void handleDataRead(ByteArray data) { + context.handleDataFromNetwork(data); + } + + public boolean setClientCertificate(PKCS12Certificate certificate) { + return context.setClientCertificate(certificate); + } + + public Certificate getPeerCertificate() { + return context.getPeerCertificate(); + } + + public CertificateVerificationError getPeerCertificateVerificationError() { + return context.getPeerCertificateVerificationError(); + } + + public TLSContext getContext() { + return context; + } + + public final Signal onError = new Signal(); + public final Signal onConnected = new Signal(); + + private final TLSContext context; +} diff --git a/src/com/isode/stroke/streamstack/WhitespacePingLayer.java b/src/com/isode/stroke/streamstack/WhitespacePingLayer.java new file mode 100644 index 0000000..09d3af8 --- /dev/null +++ b/src/com/isode/stroke/streamstack/WhitespacePingLayer.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.network.Timer; +import com.isode.stroke.network.TimerFactory; +import com.isode.stroke.signals.Slot; + +public class WhitespacePingLayer extends StreamLayer { + + private static final int TIMEOUT_MILLISECONDS = 60000; + + public WhitespacePingLayer(TimerFactory timerFactory) { + isActive = false; + timer = timerFactory.createTimer(TIMEOUT_MILLISECONDS); + timer.onTick.connect(new Slot() { + public void call() { + handleTimerTick(); + } + }); + } + + public void writeData(ByteArray data) { + writeDataToChildLayer(data); + } + + public void handleDataRead(ByteArray data) { + writeDataToParentLayer(data); + } + + private void handleTimerTick() { + timer.stop(); + writeDataToChildLayer(new ByteArray(" ")); + timer.start(); + } + + public void setActive() { + isActive = true; + timer.start(); + } + + public void setInactive() { + timer.stop(); + isActive = false; + } + + public boolean getIsActive() { + return isActive; + } + + private boolean isActive; + private Timer timer; +} diff --git a/src/com/isode/stroke/streamstack/XMPPLayer.java b/src/com/isode/stroke/streamstack/XMPPLayer.java new file mode 100644 index 0000000..86c7b0e --- /dev/null +++ b/src/com/isode/stroke/streamstack/XMPPLayer.java @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010-2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.streamstack; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.elements.Element; +import com.isode.stroke.elements.ProtocolHeader; +import com.isode.stroke.elements.StreamType; +import com.isode.stroke.eventloop.EventLoop; +import com.isode.stroke.parser.PayloadParserFactoryCollection; +import com.isode.stroke.parser.XMPPParser; +import com.isode.stroke.parser.XMPPParserClient; +import com.isode.stroke.serializer.PayloadSerializerCollection; +import com.isode.stroke.serializer.XMPPSerializer; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; + +/** + * This uses the inner StreamLayer to work around the HighLayer not having + * implementations because of the lack of multiple inheritance. + * Swiften doesn't require an eventLoop, Stroke does because of + * XML parsing being multi-threaded here. + */ +public class XMPPLayer implements HighLayer, XMPPParserClient { + + public XMPPLayer( + PayloadParserFactoryCollection payloadParserFactories, + PayloadSerializerCollection payloadSerializers, + StreamType streamType, + EventLoop eventLoop) { + payloadParserFactories_ = payloadParserFactories; + payloadSerializers_ = payloadSerializers; + resetParserAfterParse_ = false; + eventLoop_ = eventLoop; + inParser_ = false; + xmppParser_ = new XMPPParser(this, payloadParserFactories_, eventLoop_); + xmppSerializer_ = new XMPPSerializer(payloadSerializers_, streamType); + } + + public void writeHeader(ProtocolHeader header) { + writeDataInternal(new ByteArray(xmppSerializer_.serializeHeader(header))); + } + + public void writeFooter() { + writeDataInternal(new ByteArray(xmppSerializer_.serializeFooter())); + } + + public void writeElement(Element element) { + writeDataInternal(new ByteArray(xmppSerializer_.serializeElement(element))); + } + + public void writeData(String data) { + writeDataInternal(new ByteArray(data)); + } + + public void resetParser() { + if (inParser_) { + resetParserAfterParse_ = true; + } + else { + doResetParser(); + } + } + + /** + * Should be protected, but can't because of interface implementation. + * @param data + */ + public void handleDataRead(ByteArray data) { + handleDataReadInternal(data); + } + + protected void writeDataInternal(ByteArray data) { + onWriteData.emit(data); + writeDataToChildLayer(data); + } + + public final Signal1<ProtocolHeader> onStreamStart = new Signal1<ProtocolHeader>(); + public final Signal1<Element> onElement = new Signal1<Element>(); + public final Signal1<ByteArray> onWriteData = new Signal1<ByteArray>(); + public final Signal1<ByteArray> onDataRead = new Signal1<ByteArray>(); + public final Signal onError = new Signal(); + + public void handleStreamStart(ProtocolHeader header) { + onStreamStart.emit(header); + } + + public void handleElement(Element element) { + onElement.emit(element); + } + + public void handleStreamEnd() { + } + + private void doResetParser() { + xmppParser_ = new XMPPParser(this, payloadParserFactories_, eventLoop_); + resetParserAfterParse_ = false; + } + + private PayloadParserFactoryCollection payloadParserFactories_; + private XMPPParser xmppParser_; + private PayloadSerializerCollection payloadSerializers_; + private XMPPSerializer xmppSerializer_; + private boolean resetParserAfterParse_; + private boolean inParser_; + private EventLoop eventLoop_; + + /* Multiple-inheritance workarounds */ + + private StreamLayer fakeStreamLayer_ = new StreamLayer() { + public void writeData(ByteArray data) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public void handleDataRead(ByteArray data) { + handleDataReadInternal(data); + } + }; + + private void handleDataReadInternal(ByteArray data) { + onDataRead.emit(data); + inParser_ = true; + if(!xmppParser_.parse(data.toString())) { + inParser_ = false; + onError.emit(); + return; + } + inParser_ = false; + if (resetParserAfterParse_) { + doResetParser(); + } + } + + public LowLayer getChildLayer() { + return fakeStreamLayer_.getChildLayer(); + } + + public void setChildLayer(LowLayer childLayer) { + fakeStreamLayer_.setChildLayer(childLayer); + } + + public void writeDataToChildLayer(ByteArray data) { + fakeStreamLayer_.writeDataToChildLayer(data); + } +} diff --git a/src/com/isode/stroke/stringcodecs/Base64.java b/src/com/isode/stroke/stringcodecs/Base64.java new file mode 100644 index 0000000..3b0faa5 --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/Base64.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.stringcodecs; + +import com.isode.stroke.base.ByteArray; + +public class Base64 { + /* FIXME: Check license is ok (it is, it's BSD) */ + public static ByteArray decode(String input) { + return new ByteArray(Base64BSD.decode(input)); + } + + public static String encode(ByteArray input) { + return Base64BSD.encodeToString(input.getData(), false); + } +} diff --git a/src/com/isode/stroke/stringcodecs/Base64BSD.java b/src/com/isode/stroke/stringcodecs/Base64BSD.java new file mode 100644 index 0000000..9a3e0e4 --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/Base64BSD.java @@ -0,0 +1,575 @@ +package com.isode.stroke.stringcodecs;
+
+import java.util.Arrays;
+
+/** A very fast and memory efficient class to encode and decode to and from BASE64 in full accordance
+ * with RFC 2045.<br><br>
+ * On Windows XP sp1 with 1.4.2_04 and later ;), this encoder and decoder is about 10 times faster
+ * on small arrays (10 - 1000 bytes) and 2-3 times as fast on larger arrays (10000 - 1000000 bytes)
+ * compared to <code>sun.misc.Encoder()/Decoder()</code>.<br><br>
+ *
+ * On byte arrays the encoder is about 20% faster than Jakarta Commons Base64 Codec for encode and
+ * about 50% faster for decoding large arrays. This implementation is about twice as fast on very small
+ * arrays (< 30 bytes). If source/destination is a <code>String</code> this
+ * version is about three times as fast due to the fact that the Commons Codec result has to be recoded
+ * to a <code>String</code> from <code>byte[]</code>, which is very expensive.<br><br>
+ *
+ * This encode/decode algorithm doesn't create any temporary arrays as many other codecs do, it only
+ * allocates the resulting array. This produces less garbage and it is possible to handle arrays twice
+ * as large as algorithms that create a temporary array. (E.g. Jakarta Commons Codec). It is unknown
+ * whether Sun's <code>sun.misc.Encoder()/Decoder()</code> produce temporary arrays but since performance
+ * is quite low it probably does.<br><br>
+ *
+ * The encoder produces the same output as the Sun one except that the Sun's encoder appends
+ * a trailing line separator if the last character isn't a pad. Unclear why but it only adds to the
+ * length and is probably a side effect. Both are in conformance with RFC 2045 though.<br>
+ * Commons codec seem to always att a trailing line separator.<br><br>
+ *
+ * <b>Note!</b>
+ * The encode/decode method pairs (types) come in three versions with the <b>exact</b> same algorithm and
+ * thus a lot of code redundancy. This is to not create any temporary arrays for transcoding to/from different
+ * format types. The methods not used can simply be commented out.<br><br>
+ *
+ * There is also a "fast" version of all decode methods that works the same way as the normal ones, but
+ * har a few demands on the decoded input. Normally though, these fast verions should be used if the source if
+ * the input is known and it hasn't bee tampered with.<br><br>
+ *
+ * If you find the code useful or you find a bug, please send me a note at base64 @ miginfocom . com.
+ *
+ * Licence (BSD):
+ * ==============
+ *
+ * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (base64 @ miginfocom . com)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or other
+ * materials provided with the distribution.
+ * Neither the name of the MiG InfoCom AB nor the names of its contributors may be
+ * used to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * @version 2.2
+ * @author Mikael Grev
+ * Date: 2004-aug-02
+ * Time: 11:31:11
+ */
+
+public class Base64BSD
+{
+ private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
+ private static final int[] IA = new int[256];
+ static {
+ Arrays.fill(IA, -1);
+ for (int i = 0, iS = CA.length; i < iS; i++)
+ IA[CA[i]] = i;
+ IA['='] = 0;
+ }
+
+ // ****************************************************************************************
+ // * char[] version
+ // ****************************************************************************************
+
+ /** Encodes a raw byte array into a BASE64 <code>char[]</code> representation i accordance with RFC 2045.
+ * @param sArr The bytes to convert. If <code>null</code> or length 0 an empty array will be returned.
+ * @param lineSep Optional "\r\n" after 76 characters, unless end of file.<br>
+ * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
+ * little faster.
+ * @return A BASE64 encoded array. Never <code>null</code>.
+ */
+ public final static char[] encodeToChar(byte[] sArr, boolean lineSep)
+ {
+ // Check special case
+ int sLen = sArr != null ? sArr.length : 0;
+ if (sLen == 0)
+ return new char[0];
+
+ int eLen = (sLen / 3) * 3; // Length of even 24-bits.
+ int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count
+ int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array
+ char[] dArr = new char[dLen];
+
+ // Encode even 24-bits
+ for (int s = 0, d = 0, cc = 0; s < eLen;) {
+ // Copy next three bytes into lower 24 bits of int, paying attension to sign.
+ int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff);
+
+ // Encode the int into four chars
+ dArr[d++] = CA[(i >>> 18) & 0x3f];
+ dArr[d++] = CA[(i >>> 12) & 0x3f];
+ dArr[d++] = CA[(i >>> 6) & 0x3f];
+ dArr[d++] = CA[i & 0x3f];
+
+ // Add optional line separator
+ if (lineSep && ++cc == 19 && d < dLen - 2) {
+ dArr[d++] = '\r';
+ dArr[d++] = '\n';
+ cc = 0;
+ }
+ }
+
+ // Pad and encode last bits if source isn't even 24 bits.
+ int left = sLen - eLen; // 0 - 2.
+ if (left > 0) {
+ // Prepare the int
+ int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0);
+
+ // Set last four chars
+ dArr[dLen - 4] = CA[i >> 12];
+ dArr[dLen - 3] = CA[(i >>> 6) & 0x3f];
+ dArr[dLen - 2] = left == 2 ? CA[i & 0x3f] : '=';
+ dArr[dLen - 1] = '=';
+ }
+ return dArr;
+ }
+
+ /** Decodes a BASE64 encoded char array. All illegal characters will be ignored and can handle both arrays with
+ * and without line separators.
+ * @param sArr The source array. <code>null</code> or length 0 will return an empty array.
+ * @return The decoded array of bytes. May be of length 0. Will be <code>null</code> if the legal characters
+ * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
+ */
+ public final static byte[] decode(char[] sArr)
+ {
+ // Check special case
+ int sLen = sArr != null ? sArr.length : 0;
+ if (sLen == 0)
+ return new byte[0];
+
+ // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
+ // so we don't have to reallocate & copy it later.
+ int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
+ for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
+ if (IA[sArr[i]] < 0)
+ sepCnt++;
+
+ // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
+ if ((sLen - sepCnt) % 4 != 0)
+ return null;
+
+ int pad = 0;
+ for (int i = sLen; i > 1 && IA[sArr[--i]] <= 0;)
+ if (sArr[i] == '=')
+ pad++;
+
+ int len = ((sLen - sepCnt) * 6 >> 3) - pad;
+
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ for (int s = 0, d = 0; d < len;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = 0;
+ for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
+ int c = IA[sArr[s++]];
+ if (c >= 0)
+ i |= c << (18 - j * 6);
+ else
+ j--;
+ }
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ if (d < len) {
+ dArr[d++]= (byte) (i >> 8);
+ if (d < len)
+ dArr[d++] = (byte) i;
+ }
+ }
+ return dArr;
+ }
+
+ /** Decodes a BASE64 encoded char array that is known to be resonably well formatted. The method is about twice as
+ * fast as {@link #decode(char[])}. The preconditions are:<br>
+ * + The array must have a line length of 76 chars OR no line separators at all (one line).<br>
+ * + Line separator must be "\r\n", as specified in RFC 2045
+ * + The array must not contain illegal characters within the encoded string<br>
+ * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.<br>
+ * @param sArr The source array. Length 0 will return an empty array. <code>null</code> will throw an exception.
+ * @return The decoded array of bytes. May be of length 0.
+ */
+ public final static byte[] decodeFast(char[] sArr)
+ {
+ // Check special case
+ int sLen = sArr.length;
+ if (sLen == 0)
+ return new byte[0];
+
+ int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
+
+ // Trim illegal chars from start
+ while (sIx < eIx && IA[sArr[sIx]] < 0)
+ sIx++;
+
+ // Trim illegal chars from end
+ while (eIx > 0 && IA[sArr[eIx]] < 0)
+ eIx--;
+
+ // get the padding count (=) (0, 1 or 2)
+ int pad = sArr[eIx] == '=' ? (sArr[eIx - 1] == '=' ? 2 : 1) : 0; // Count '=' at end.
+ int cCnt = eIx - sIx + 1; // Content count including possible separators
+ int sepCnt = sLen > 76 ? (sArr[76] == '\r' ? cCnt / 78 : 0) << 1 : 0;
+
+ int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ // Decode all but the last 0 - 2 bytes.
+ int d = 0;
+ for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = IA[sArr[sIx++]] << 18 | IA[sArr[sIx++]] << 12 | IA[sArr[sIx++]] << 6 | IA[sArr[sIx++]];
+
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ dArr[d++] = (byte) (i >> 8);
+ dArr[d++] = (byte) i;
+
+ // If line separator, jump over it.
+ if (sepCnt > 0 && ++cc == 19) {
+ sIx += 2;
+ cc = 0;
+ }
+ }
+
+ if (d < len) {
+ // Decode last 1-3 bytes (incl '=') into 1-3 bytes
+ int i = 0;
+ for (int j = 0; sIx <= eIx - pad; j++)
+ i |= IA[sArr[sIx++]] << (18 - j * 6);
+
+ for (int r = 16; d < len; r -= 8)
+ dArr[d++] = (byte) (i >> r);
+ }
+
+ return dArr;
+ }
+
+ // ****************************************************************************************
+ // * byte[] version
+ // ****************************************************************************************
+
+ /** Encodes a raw byte array into a BASE64 <code>byte[]</code> representation i accordance with RFC 2045.
+ * @param sArr The bytes to convert. If <code>null</code> or length 0 an empty array will be returned.
+ * @param lineSep Optional "\r\n" after 76 characters, unless end of file.<br>
+ * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
+ * little faster.
+ * @return A BASE64 encoded array. Never <code>null</code>.
+ */
+ public final static byte[] encodeToByte(byte[] sArr, boolean lineSep)
+ {
+ // Check special case
+ int sLen = sArr != null ? sArr.length : 0;
+ if (sLen == 0)
+ return new byte[0];
+
+ int eLen = (sLen / 3) * 3; // Length of even 24-bits.
+ int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count
+ int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array
+ byte[] dArr = new byte[dLen];
+
+ // Encode even 24-bits
+ for (int s = 0, d = 0, cc = 0; s < eLen;) {
+ // Copy next three bytes into lower 24 bits of int, paying attension to sign.
+ int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff);
+
+ // Encode the int into four chars
+ dArr[d++] = (byte) CA[(i >>> 18) & 0x3f];
+ dArr[d++] = (byte) CA[(i >>> 12) & 0x3f];
+ dArr[d++] = (byte) CA[(i >>> 6) & 0x3f];
+ dArr[d++] = (byte) CA[i & 0x3f];
+
+ // Add optional line separator
+ if (lineSep && ++cc == 19 && d < dLen - 2) {
+ dArr[d++] = '\r';
+ dArr[d++] = '\n';
+ cc = 0;
+ }
+ }
+
+ // Pad and encode last bits if source isn't an even 24 bits.
+ int left = sLen - eLen; // 0 - 2.
+ if (left > 0) {
+ // Prepare the int
+ int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0);
+
+ // Set last four chars
+ dArr[dLen - 4] = (byte) CA[i >> 12];
+ dArr[dLen - 3] = (byte) CA[(i >>> 6) & 0x3f];
+ dArr[dLen - 2] = left == 2 ? (byte) CA[i & 0x3f] : (byte) '=';
+ dArr[dLen - 1] = '=';
+ }
+ return dArr;
+ }
+
+ /** Decodes a BASE64 encoded byte array. All illegal characters will be ignored and can handle both arrays with
+ * and without line separators.
+ * @param sArr The source array. Length 0 will return an empty array. <code>null</code> will throw an exception.
+ * @return The decoded array of bytes. May be of length 0. Will be <code>null</code> if the legal characters
+ * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
+ */
+ public final static byte[] decode(byte[] sArr)
+ {
+ // Check special case
+ int sLen = sArr.length;
+
+ // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
+ // so we don't have to reallocate & copy it later.
+ int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
+ for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
+ if (IA[sArr[i] & 0xff] < 0)
+ sepCnt++;
+
+ // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
+ if ((sLen - sepCnt) % 4 != 0)
+ return null;
+
+ int pad = 0;
+ for (int i = sLen; i > 1 && IA[sArr[--i] & 0xff] <= 0;)
+ if (sArr[i] == '=')
+ pad++;
+
+ int len = ((sLen - sepCnt) * 6 >> 3) - pad;
+
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ for (int s = 0, d = 0; d < len;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = 0;
+ for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
+ int c = IA[sArr[s++] & 0xff];
+ if (c >= 0)
+ i |= c << (18 - j * 6);
+ else
+ j--;
+ }
+
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ if (d < len) {
+ dArr[d++]= (byte) (i >> 8);
+ if (d < len)
+ dArr[d++] = (byte) i;
+ }
+ }
+
+ return dArr;
+ }
+
+
+ /** Decodes a BASE64 encoded byte array that is known to be resonably well formatted. The method is about twice as
+ * fast as {@link #decode(byte[])}. The preconditions are:<br>
+ * + The array must have a line length of 76 chars OR no line separators at all (one line).<br>
+ * + Line separator must be "\r\n", as specified in RFC 2045
+ * + The array must not contain illegal characters within the encoded string<br>
+ * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.<br>
+ * @param sArr The source array. Length 0 will return an empty array. <code>null</code> will throw an exception.
+ * @return The decoded array of bytes. May be of length 0.
+ */
+ public final static byte[] decodeFast(byte[] sArr)
+ {
+ // Check special case
+ int sLen = sArr.length;
+ if (sLen == 0)
+ return new byte[0];
+
+ int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
+
+ // Trim illegal chars from start
+ while (sIx < eIx && IA[sArr[sIx] & 0xff] < 0)
+ sIx++;
+
+ // Trim illegal chars from end
+ while (eIx > 0 && IA[sArr[eIx] & 0xff] < 0)
+ eIx--;
+
+ // get the padding count (=) (0, 1 or 2)
+ int pad = sArr[eIx] == '=' ? (sArr[eIx - 1] == '=' ? 2 : 1) : 0; // Count '=' at end.
+ int cCnt = eIx - sIx + 1; // Content count including possible separators
+ int sepCnt = sLen > 76 ? (sArr[76] == '\r' ? cCnt / 78 : 0) << 1 : 0;
+
+ int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ // Decode all but the last 0 - 2 bytes.
+ int d = 0;
+ for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = IA[sArr[sIx++]] << 18 | IA[sArr[sIx++]] << 12 | IA[sArr[sIx++]] << 6 | IA[sArr[sIx++]];
+
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ dArr[d++] = (byte) (i >> 8);
+ dArr[d++] = (byte) i;
+
+ // If line separator, jump over it.
+ if (sepCnt > 0 && ++cc == 19) {
+ sIx += 2;
+ cc = 0;
+ }
+ }
+
+ if (d < len) {
+ // Decode last 1-3 bytes (incl '=') into 1-3 bytes
+ int i = 0;
+ for (int j = 0; sIx <= eIx - pad; j++)
+ i |= IA[sArr[sIx++]] << (18 - j * 6);
+
+ for (int r = 16; d < len; r -= 8)
+ dArr[d++] = (byte) (i >> r);
+ }
+
+ return dArr;
+ }
+
+ // ****************************************************************************************
+ // * String version
+ // ****************************************************************************************
+
+ /** Encodes a raw byte array into a BASE64 <code>String</code> representation i accordance with RFC 2045.
+ * @param sArr The bytes to convert. If <code>null</code> or length 0 an empty array will be returned.
+ * @param lineSep Optional "\r\n" after 76 characters, unless end of file.<br>
+ * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
+ * little faster.
+ * @return A BASE64 encoded array. Never <code>null</code>.
+ */
+ public final static String encodeToString(byte[] sArr, boolean lineSep)
+ {
+ // Reuse char[] since we can't create a String incrementally anyway and StringBuffer/Builder would be slower.
+ return new String(encodeToChar(sArr, lineSep));
+ }
+
+ /** Decodes a BASE64 encoded <code>String</code>. All illegal characters will be ignored and can handle both strings with
+ * and without line separators.<br>
+ * <b>Note!</b> It can be up to about 2x the speed to call <code>decode(str.toCharArray())</code> instead. That
+ * will create a temporary array though. This version will use <code>str.charAt(i)</code> to iterate the string.
+ * @param str The source string. <code>null</code> or length 0 will return an empty array.
+ * @return The decoded array of bytes. May be of length 0. Will be <code>null</code> if the legal characters
+ * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
+ */
+ public final static byte[] decode(String str)
+ {
+ // Check special case
+ int sLen = str != null ? str.length() : 0;
+ if (sLen == 0)
+ return new byte[0];
+
+ // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
+ // so we don't have to reallocate & copy it later.
+ int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
+ for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
+ if (IA[str.charAt(i)] < 0)
+ sepCnt++;
+
+ // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
+ if ((sLen - sepCnt) % 4 != 0)
+ return null;
+
+ // Count '=' at end
+ int pad = 0;
+ for (int i = sLen; i > 1 && IA[str.charAt(--i)] <= 0;)
+ if (str.charAt(i) == '=')
+ pad++;
+
+ int len = ((sLen - sepCnt) * 6 >> 3) - pad;
+
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ for (int s = 0, d = 0; d < len;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = 0;
+ for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
+ int c = IA[str.charAt(s++)];
+ if (c >= 0)
+ i |= c << (18 - j * 6);
+ else
+ j--;
+ }
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ if (d < len) {
+ dArr[d++]= (byte) (i >> 8);
+ if (d < len)
+ dArr[d++] = (byte) i;
+ }
+ }
+ return dArr;
+ }
+
+ /** Decodes a BASE64 encoded string that is known to be resonably well formatted. The method is about twice as
+ * fast as {@link #decode(String)}. The preconditions are:<br>
+ * + The array must have a line length of 76 chars OR no line separators at all (one line).<br>
+ * + Line separator must be "\r\n", as specified in RFC 2045
+ * + The array must not contain illegal characters within the encoded string<br>
+ * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.<br>
+ * @param s The source string. Length 0 will return an empty array. <code>null</code> will throw an exception.
+ * @return The decoded array of bytes. May be of length 0.
+ */
+ public final static byte[] decodeFast(String s)
+ {
+ // Check special case
+ int sLen = s.length();
+ if (sLen == 0)
+ return new byte[0];
+
+ int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
+
+ // Trim illegal chars from start
+ while (sIx < eIx && IA[s.charAt(sIx) & 0xff] < 0)
+ sIx++;
+
+ // Trim illegal chars from end
+ while (eIx > 0 && IA[s.charAt(eIx) & 0xff] < 0)
+ eIx--;
+
+ // get the padding count (=) (0, 1 or 2)
+ int pad = s.charAt(eIx) == '=' ? (s.charAt(eIx - 1) == '=' ? 2 : 1) : 0; // Count '=' at end.
+ int cCnt = eIx - sIx + 1; // Content count including possible separators
+ int sepCnt = sLen > 76 ? (s.charAt(76) == '\r' ? cCnt / 78 : 0) << 1 : 0;
+
+ int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
+ byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
+
+ // Decode all but the last 0 - 2 bytes.
+ int d = 0;
+ for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
+ // Assemble three bytes into an int from four "valid" characters.
+ int i = IA[s.charAt(sIx++)] << 18 | IA[s.charAt(sIx++)] << 12 | IA[s.charAt(sIx++)] << 6 | IA[s.charAt(sIx++)];
+
+ // Add the bytes
+ dArr[d++] = (byte) (i >> 16);
+ dArr[d++] = (byte) (i >> 8);
+ dArr[d++] = (byte) i;
+
+ // If line separator, jump over it.
+ if (sepCnt > 0 && ++cc == 19) {
+ sIx += 2;
+ cc = 0;
+ }
+ }
+
+ if (d < len) {
+ // Decode last 1-3 bytes (incl '=') into 1-3 bytes
+ int i = 0;
+ for (int j = 0; sIx <= eIx - pad; j++)
+ i |= IA[s.charAt(sIx++)] << (18 - j * 6);
+
+ for (int r = 16; d < len; r -= 8)
+ dArr[d++] = (byte) (i >> r);
+ }
+
+ return dArr;
+ }
+}
\ No newline at end of file diff --git a/src/com/isode/stroke/stringcodecs/HMACSHA1.java b/src/com/isode/stroke/stringcodecs/HMACSHA1.java new file mode 100644 index 0000000..1d8c9b7 --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/HMACSHA1.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.stringcodecs; + +import com.isode.stroke.base.ByteArray; + +public class HMACSHA1 { + + private static final int B = 64; + + public static ByteArray getResult(ByteArray key, ByteArray data) { + assert key.getSize() <= B; + + /* And an assert that does something */ + if (key.getSize() > B) { + throw new IllegalStateException("Invalid key size."); + } + + // Create the padded key + ByteArray paddedKey = new ByteArray(key); + for (int i = key.getSize(); i < B; ++i) { + paddedKey.append((byte) 0x0); + } + + // Create the first value + ByteArray x = new ByteArray(paddedKey); + byte[] xInner = x.getData(); + for (int i = 0; i < xInner.length; ++i) { + xInner[i] ^= 0x36; + } + x.append(data); + + // Create the second value + ByteArray y = new ByteArray(paddedKey); + byte[] yInner = y.getData(); + for (int i = 0; i < yInner.length; ++i) { + yInner[i] ^= 0x5c; + } + y.append(SHA1.getHash(x)); + + return SHA1.getHash(y); + } +} diff --git a/src/com/isode/stroke/stringcodecs/Hexify.java b/src/com/isode/stroke/stringcodecs/Hexify.java new file mode 100644 index 0000000..7f51fb9 --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/Hexify.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.stringcodecs; + +import com.isode.stroke.base.ByteArray; + +public class Hexify { + + public static String hexify(byte datum) { + return String.format("%x", new Byte(datum)); + } + + public static String hexify(ByteArray data) { + StringBuilder result = new StringBuilder(); + for (byte b : data.getData()) { + result.append(hexify(b)); + } + return result.toString(); + } +} diff --git a/src/com/isode/stroke/stringcodecs/PBKDF2.java b/src/com/isode/stroke/stringcodecs/PBKDF2.java new file mode 100644 index 0000000..547cbec --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/PBKDF2.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.stringcodecs; + +import com.isode.stroke.base.ByteArray; + +public class PBKDF2 { + + public static ByteArray encode(ByteArray password, ByteArray salt, int iterations) { + ByteArray u = HMACSHA1.getResult(password, ByteArray.plus(salt, new ByteArray("\0\0\0\1"))); + ByteArray result = new ByteArray(u); + byte[] resultData = result.getData(); + int i = 1; + while (i < iterations) { + u = HMACSHA1.getResult(password, u); + for (int j = 0; j < u.getSize(); ++j) { + resultData[j] ^= u.getData()[j]; + } + ++i; + } + return result; + } +} diff --git a/src/com/isode/stroke/stringcodecs/SHA1.java b/src/com/isode/stroke/stringcodecs/SHA1.java new file mode 100644 index 0000000..e3d0e79 --- /dev/null +++ b/src/com/isode/stroke/stringcodecs/SHA1.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2010, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.stringcodecs; + +import com.isode.stroke.base.ByteArray; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +public class SHA1 { + + public static ByteArray getHash(ByteArray data) { + MessageDigest md; + try { + md = MessageDigest.getInstance("SHA-1"); + } catch (NoSuchAlgorithmException ex) { + throw new IllegalStateException("JRE doesn't have an SHA hash function", ex); + } + md.update(data.getData()); + return new ByteArray(md.digest()); + } +} diff --git a/src/com/isode/stroke/tls/Certificate.java b/src/com/isode/stroke/tls/Certificate.java new file mode 100644 index 0000000..ac7daed --- /dev/null +++ b/src/com/isode/stroke/tls/Certificate.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.tls; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.stringcodecs.Hexify; +import com.isode.stroke.stringcodecs.SHA1; +import java.util.List; + +public abstract class Certificate { + + /** + * Returns the textual representation of the full Subject + * name. + */ + public abstract String getSubjectName(); + + public abstract List<String> getCommonNames(); + + public abstract List<String> getSRVNames(); + + public abstract List<String> getDNSNames(); + + public abstract List<String> getXMPPAddresses(); + + public abstract ByteArray toDER(); + + public String getSHA1Fingerprint() { + ByteArray hash = SHA1.getHash(toDER()); + StringBuilder s = new StringBuilder(); + for (int i = 0; i < hash.getSize(); ++i) { + if (i > 0) { + s.append(":"); + } + s.append(Hexify.hexify(hash.getData()[i])); + } + return s.toString(); + } + protected String ID_ON_XMPPADDR_OID = "1.3.6.1.5.5.7.8.5"; + protected String ID_ON_DNSSRV_OID = "1.3.6.1.5.5.7.8.7"; +} diff --git a/src/com/isode/stroke/tls/CertificateFactory.java b/src/com/isode/stroke/tls/CertificateFactory.java new file mode 100644 index 0000000..a4c34db --- /dev/null +++ b/src/com/isode/stroke/tls/CertificateFactory.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.tls; + +import com.isode.stroke.base.ByteArray; + +public interface CertificateFactory { + Certificate createCertificateFromDER(ByteArray der); +} diff --git a/src/com/isode/stroke/tls/CertificateTrustChecker.java b/src/com/isode/stroke/tls/CertificateTrustChecker.java new file mode 100644 index 0000000..08d4506 --- /dev/null +++ b/src/com/isode/stroke/tls/CertificateTrustChecker.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.tls; + +/** + * A class to implement a check for certificate trust. + */ +public interface CertificateTrustChecker { + + /** + * This method is called to find out whether a certificate is + * trusted. This usually happens when a certificate's validation + * fails, to check whether to proceed with the connection or not. + */ + boolean isCertificateTrusted(Certificate certificate); +} diff --git a/src/com/isode/stroke/tls/CertificateVerificationError.java b/src/com/isode/stroke/tls/CertificateVerificationError.java new file mode 100644 index 0000000..a8309ca --- /dev/null +++ b/src/com/isode/stroke/tls/CertificateVerificationError.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.tls; + +import com.isode.stroke.base.Error; + +public class CertificateVerificationError implements Error { + + public enum Type { + + UnknownError, + Expired, + NotYetValid, + SelfSigned, + Rejected, + Untrusted, + InvalidPurpose, + PathLengthExceeded, + InvalidSignature, + InvalidCA, + InvalidServerIdentity, + }; + + public CertificateVerificationError(Type type) { + if (type == null) { + throw new IllegalStateException(); + } + this.type = type; + } + public final Type type; +}; + diff --git a/src/com/isode/stroke/tls/PKCS12Certificate.java b/src/com/isode/stroke/tls/PKCS12Certificate.java new file mode 100644 index 0000000..af66545 --- /dev/null +++ b/src/com/isode/stroke/tls/PKCS12Certificate.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.tls; + +import com.isode.stroke.base.ByteArray; + +public class PKCS12Certificate { + + public PKCS12Certificate() { + } + + public PKCS12Certificate(String filename, String password) { + password_ = password; + data_.readFromFile(filename); + } + + public boolean isNull() { + return data_.isEmpty(); + } + + public ByteArray getData() { + return data_; + } + + public void setData(ByteArray data) { + data_ = data; + } + + public String getPassword() { + return password_; + } + private ByteArray data_; + private String password_; +} diff --git a/src/com/isode/stroke/tls/PlatformTLSFactories.java b/src/com/isode/stroke/tls/PlatformTLSFactories.java new file mode 100644 index 0000000..0959d07 --- /dev/null +++ b/src/com/isode/stroke/tls/PlatformTLSFactories.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2011 Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010 Remko Tron¨on. + * All rights reserved. + */ +package com.isode.stroke.tls; + +public class PlatformTLSFactories { + public TLSContextFactory getTLSContextFactory() { + /*FIXME: Implement*/ + return null; + } + + public CertificateFactory getCertificateFactory() { + /*FIXME: Implement*/ + return null; + } +} diff --git a/src/com/isode/stroke/tls/ServerIdentityVerifier.java b/src/com/isode/stroke/tls/ServerIdentityVerifier.java new file mode 100644 index 0000000..903b296 --- /dev/null +++ b/src/com/isode/stroke/tls/ServerIdentityVerifier.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2010 Remko Tron¨on + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +package com.isode.stroke.tls; + +import com.isode.stroke.idn.IDNA; +import com.isode.stroke.jid.JID; +import java.util.List; + +public class ServerIdentityVerifier { + + public ServerIdentityVerifier(JID jid) { + domain = jid.getDomain(); + encodedDomain = IDNA.getEncoded(domain); + } + + public boolean certificateVerifies(Certificate certificate) { + boolean hasSAN = false; + + // DNS names + List<String> dnsNames = certificate.getDNSNames(); + for (String dnsName : dnsNames) { + if (matchesDomain(dnsName)) { + return true; + } + } + hasSAN |= !dnsNames.isEmpty(); + + // SRV names + List<String> srvNames = certificate.getSRVNames(); + for (String srvName : srvNames) { + // Only match SRV names that begin with the service; this isn't required per + // spec, but we're being purist about this. + if (srvName.startsWith("_xmpp-client.") && matchesDomain(srvName.substring("_xmpp-client.".length()))) { + return true; + } + } + hasSAN |= !srvNames.isEmpty(); + + // XmppAddr + List<String> xmppAddresses = certificate.getXMPPAddresses(); + for (String xmppAddress : xmppAddresses) { + if (matchesAddress(xmppAddress)) { + return true; + } + } + hasSAN |= !xmppAddresses.isEmpty(); + + // CommonNames. Only check this if there was no SAN (according to spec). + if (!hasSAN) { + List<String> commonNames = certificate.getCommonNames(); + for (String commonName : commonNames) { + if (matchesDomain(commonName)) { + return true; + } + } + } + + return false; + } + + boolean matchesDomain(String s) { + if (s.startsWith("*.")) { + String matchString = s.substring(2); + String matchDomain = encodedDomain; + int dotIndex = matchDomain.indexOf('.'); + if (dotIndex >= 0) { + matchDomain = matchDomain.substring(dotIndex + 1); + } + return matchString.equals(matchDomain); + } + else { + return s.equals(encodedDomain); + } + } + + boolean matchesAddress(String s) { + return s.equals(domain); + } + private String domain; + private String encodedDomain; +} diff --git a/src/com/isode/stroke/tls/TLSContext.java b/src/com/isode/stroke/tls/TLSContext.java new file mode 100644 index 0000000..16f2ae3 --- /dev/null +++ b/src/com/isode/stroke/tls/TLSContext.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.tls; + +import com.isode.stroke.base.ByteArray; +import com.isode.stroke.signals.Signal; +import com.isode.stroke.signals.Signal1; + +public abstract class TLSContext { + //See SSLEngine for real implementation when the time comes + public abstract void connect(); + + public abstract boolean setClientCertificate(PKCS12Certificate cert); + + public abstract void handleDataFromNetwork(ByteArray data); + public abstract void handleDataFromApplication(ByteArray data); + + public abstract Certificate getPeerCertificate(); + public abstract CertificateVerificationError getPeerCertificateVerificationError(); + + public abstract ByteArray getFinishMessage(); + + public Signal1<ByteArray> onDataForNetwork = new Signal1<ByteArray>(); + public Signal1<ByteArray> onDataForApplication = new Signal1<ByteArray>(); + public Signal onError = new Signal(); + public Signal onConnected = new Signal(); +} diff --git a/src/com/isode/stroke/tls/TLSContextFactory.java b/src/com/isode/stroke/tls/TLSContextFactory.java new file mode 100644 index 0000000..1b84a42 --- /dev/null +++ b/src/com/isode/stroke/tls/TLSContextFactory.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2011, Isode Limited, London, England. + * All rights reserved. + */ +/* + * Copyright (c) 2010, Remko Tron¨on. + * All rights reserved. + */ + +package com.isode.stroke.tls; + +public interface TLSContextFactory { + boolean canCreate(); + TLSContext createTLSContext(); +} |