From ddb27b6965e94d15098d48ae8391fcb777fb97f7 Mon Sep 17 00:00:00 2001 From: adiaholic Date: Wed, 13 May 2020 15:26:08 +0530 Subject: [PATCH 1/7] Correct spellings wherever needed in `connection-modules.md` --- documentation/connection-modules.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/documentation/connection-modules.md b/documentation/connection-modules.md index 50110e6f7..ef9a40c48 100644 --- a/documentation/connection-modules.md +++ b/documentation/connection-modules.md @@ -5,7 +5,7 @@ Smack's Modular Connection Architecture **Note: Everything related to the modular connection architecture is currently considered experimental and should not be used in production. Use the mature `XMPPTCPConnection` if you do not feel adventurous. -Smack's modular connection architecture allows to extend a XMPP c2s (client-to-server) connection with additional functionalty by adding modules. +Smack's modular connection architecture allows to extend a XMPP c2s (client-to-server) connection with additional functionality by adding modules. Those modules extend the Finite State Machine (FSM) within the `ModularXmppClientToServerConnection` with new states. Connection modules can either be @@ -32,4 +32,4 @@ Connection modules are plugged into the the modular connection via their constru Modules and states always have an accompanying *descriptor* type. `ModuleDescriptor` and `StateDescriptor` exist without an connection instance. -They describe the module and state metadata, while their modules are states are instanciated once a modular connection is instanciated. +They describe the module and state metadata, while their modules and states are instanciated once a modular connection is instanciated. From 39a6e7e888bc12d417b317ce4ad02a69a8b0173a Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Wed, 13 May 2020 22:18:09 +0200 Subject: [PATCH 2/7] Add support for XEP-0428: Fallback Indication Fixes SMACK-889 --- documentation/extensions/index.md | 1 + .../FallbackIndicationListener.java | 33 ++++ .../FallbackIndicationManager.java | 174 ++++++++++++++++++ .../element/FallbackIndicationElement.java | 53 ++++++ .../element/package-info.java | 22 +++ .../fallback_indication/package-info.java | 21 +++ .../FallbackIndicationElementProvider.java | 35 ++++ .../provider/package-info.java | 22 +++ .../experimental.providers | 7 + .../FallbackIndicationTest.java | 42 +++++ 10 files changed, 410 insertions(+) create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationListener.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationManager.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/FallbackIndicationElement.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/package-info.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/package-info.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/FallbackIndicationElementProvider.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/package-info.java create mode 100644 smack-experimental/src/test/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationTest.java diff --git a/documentation/extensions/index.md b/documentation/extensions/index.md index 91f291ca4..00a9680a7 100644 --- a/documentation/extensions/index.md +++ b/documentation/extensions/index.md @@ -122,6 +122,7 @@ Experimental Smack Extensions and currently supported XEPs of smack-experimental | [Message Markup](messagemarkup.md) | [XEP-0394](https://xmpp.org/extensions/xep-0394.html) | 0.1.0 | Style message bodies while keeping body and markup information separated. | | DNS Queries over XMPP (DoX) | [XEP-0418](https://xmpp.org/extensions/xep-0418.html) | 0.1.0 | Send DNS queries and responses over XMPP. | | Message Fastening | [XEP-0422](https://xmpp.org/extensions/xep-0422.html) | 0.1.1 | Mark payloads on a message to be logistically fastened to a previous message. | +| Fallback Indication | [XEP-0428](https://xmpp.org/extensions/xep-0428.html) | 0.1.0 | Declare body elements of a message as ignorable fallback for naive legacy clients. | Unofficial XMPP Extensions -------------------------- diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationListener.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationListener.java new file mode 100644 index 000000000..b7ef22525 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationListener.java @@ -0,0 +1,33 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.fallback_indication; + +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement; + +public interface FallbackIndicationListener { + + /** + * Listener method that gets called when a {@link Message} containing a {@link FallbackIndicationElement} is received. + * + * @param message message + * @param indicator Fallback Indication + * @param fallbackBody body that is marked as fallback + */ + void onFallbackIndicationReceived(Message message, FallbackIndicationElement indicator, String fallbackBody); + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationManager.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationManager.java new file mode 100644 index 000000000..da58e6ae9 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationManager.java @@ -0,0 +1,174 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.fallback_indication; + +import java.util.Map; +import java.util.Set; +import java.util.WeakHashMap; +import java.util.concurrent.CopyOnWriteArraySet; + +import org.jivesoftware.smack.AsyncButOrdered; +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.Manager; +import org.jivesoftware.smack.SmackException; +import org.jivesoftware.smack.StanzaListener; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.XMPPConnectionRegistry; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.StanzaExtensionFilter; +import org.jivesoftware.smack.filter.StanzaFilter; +import org.jivesoftware.smack.filter.StanzaTypeFilter; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.MessageBuilder; +import org.jivesoftware.smack.packet.Stanza; +import org.jivesoftware.smackx.disco.ServiceDiscoveryManager; +import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement; + +import org.jxmpp.jid.BareJid; +import org.jxmpp.jid.EntityBareJid; + +/** + * Smacks API for XEP-0428: Fallback Indication. + * In some scenarios it might make sense to mark the body of a message as fallback for legacy clients. + * Examples are encryption mechanisms where the sender might include a hint for legacy clients stating that the + * body (eg. "This message is encrypted") should be ignored. + * + * @see XEP-0428: Fallback Indication + */ +public final class FallbackIndicationManager extends Manager { + + private static final Map INSTANCES = new WeakHashMap<>(); + + static { + XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() { + @Override + public void connectionCreated(XMPPConnection connection) { + getInstanceFor(connection); + } + }); + } + + private final Set listeners = new CopyOnWriteArraySet<>(); + private final AsyncButOrdered asyncButOrdered = new AsyncButOrdered<>(); + private final StanzaFilter fallbackIndicationElementFilter = new AndFilter(StanzaTypeFilter.MESSAGE, + new StanzaExtensionFilter(FallbackIndicationElement.ELEMENT, FallbackIndicationElement.NAMESPACE)); + + private final StanzaListener fallbackIndicationElementListener = new StanzaListener() { + @Override + public void processStanza(Stanza packet) { + Message message = (Message) packet; + FallbackIndicationElement indicator = FallbackIndicationElement.fromMessage(message); + String body = message.getBody(); + asyncButOrdered.performAsyncButOrdered(message.getFrom().asBareJid(), () -> { + for (FallbackIndicationListener l : listeners) { + l.onFallbackIndicationReceived(message, indicator, body); + } + }); + } + }; + + private FallbackIndicationManager(XMPPConnection connection) { + super(connection); + connection.addAsyncStanzaListener(fallbackIndicationElementListener, fallbackIndicationElementFilter); + ServiceDiscoveryManager.getInstanceFor(connection).addFeature(FallbackIndicationElement.NAMESPACE); + } + + public static synchronized FallbackIndicationManager getInstanceFor(XMPPConnection connection) { + FallbackIndicationManager manager = INSTANCES.get(connection); + if (manager == null) { + manager = new FallbackIndicationManager(connection); + INSTANCES.put(connection, manager); + } + return manager; + } + + /** + * Determine, whether or not a user supports Fallback Indications. + * + * @param jid BareJid of the user. + * @return feature support + * + * @throws XMPPException.XMPPErrorException if a protocol level error happens + * @throws SmackException.NotConnectedException if the connection is not connected + * @throws InterruptedException if the thread is being interrupted + * @throws SmackException.NoResponseException if the server doesn't send a response in time + */ + public boolean userSupportsFallbackIndications(EntityBareJid jid) + throws XMPPException.XMPPErrorException, SmackException.NotConnectedException, InterruptedException, + SmackException.NoResponseException { + return ServiceDiscoveryManager.getInstanceFor(connection()) + .supportsFeature(jid, FallbackIndicationElement.NAMESPACE); + } + + /** + * Determine, whether or not the server supports Fallback Indications. + * + * @return server side feature support + * + * @throws XMPPException.XMPPErrorException if a protocol level error happens + * @throws SmackException.NotConnectedException if the connection is not connected + * @throws InterruptedException if the thread is being interrupted + * @throws SmackException.NoResponseException if the server doesn't send a response in time + */ + public boolean serverSupportsFallbackIndications() + throws XMPPException.XMPPErrorException, SmackException.NotConnectedException, InterruptedException, + SmackException.NoResponseException { + return ServiceDiscoveryManager.getInstanceFor(connection()) + .serverSupportsFeature(FallbackIndicationElement.NAMESPACE); + } + + /** + * Set the body of the message to the provided fallback message and add a {@link FallbackIndicationElement}. + * + * @param messageBuilder message builder + * @param fallbackMessageBody fallback message body + * @return builder with set body and added fallback element + */ + public MessageBuilder addFallbackIndicationWithBody(MessageBuilder messageBuilder, String fallbackMessageBody) { + return addFallbackIndication(messageBuilder).setBody(fallbackMessageBody); + } + + /** + * Add a {@link FallbackIndicationElement} to the provided message builder. + * + * @param messageBuilder message builder + * @return message builder with added fallback element + */ + public MessageBuilder addFallbackIndication(MessageBuilder messageBuilder) { + return messageBuilder.addExtension(new FallbackIndicationElement()); + } + + /** + * Register a {@link FallbackIndicationListener} that gets notified whenever a message that contains a + * {@link FallbackIndicationElement} is received. + * + * @param listener listener to be registered. + */ + public synchronized void addFallbackIndicationListener(FallbackIndicationListener listener) { + listeners.add(listener); + } + + /** + * Unregister a {@link FallbackIndicationListener}. + * + * @param listener listener to be unregistered. + */ + public synchronized void removeFallbackIndicationListener(FallbackIndicationListener listener) { + listeners.remove(listener); + } +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/FallbackIndicationElement.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/FallbackIndicationElement.java new file mode 100644 index 000000000..96b06fc99 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/FallbackIndicationElement.java @@ -0,0 +1,53 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.fallback_indication.element; + +import org.jivesoftware.smack.packet.ExtensionElement; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.XmlEnvironment; +import org.jivesoftware.smack.util.XmlStringBuilder; + +public class FallbackIndicationElement implements ExtensionElement { + + public static final String NAMESPACE = "urn:xmpp:fallback:0"; + public static final String ELEMENT = "fallback"; + + public static final FallbackIndicationElement INSTANCE = new FallbackIndicationElement(); + + @Override + public String getNamespace() { + return NAMESPACE; + } + + @Override + public String getElementName() { + return ELEMENT; + } + + @Override + public XmlStringBuilder toXML(XmlEnvironment xmlEnvironment) { + return new XmlStringBuilder(this).closeEmptyElement(); + } + + public static boolean hasFallbackIndication(Message message) { + return message.hasExtension(ELEMENT, NAMESPACE); + } + + public static FallbackIndicationElement fromMessage(Message message) { + return message.getExtension(FallbackIndicationElement.class); + } +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/package-info.java new file mode 100644 index 000000000..192654509 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/package-info.java @@ -0,0 +1,22 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Smack's API for XEP-0428: Fallback Indication. + * Extension Elements. + */ +package org.jivesoftware.smackx.fallback_indication.element; diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/package-info.java new file mode 100644 index 000000000..11dfe6e80 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/package-info.java @@ -0,0 +1,21 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Smack's API for XEP-0428: Fallback Indication. + */ +package org.jivesoftware.smackx.fallback_indication; diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/FallbackIndicationElementProvider.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/FallbackIndicationElementProvider.java new file mode 100644 index 000000000..66bc9fb9e --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/FallbackIndicationElementProvider.java @@ -0,0 +1,35 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.fallback_indication.provider; + +import java.io.IOException; + +import org.jivesoftware.smack.packet.XmlEnvironment; +import org.jivesoftware.smack.parsing.SmackParsingException; +import org.jivesoftware.smack.provider.ExtensionElementProvider; +import org.jivesoftware.smack.xml.XmlPullParser; +import org.jivesoftware.smack.xml.XmlPullParserException; +import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement; + +public class FallbackIndicationElementProvider extends ExtensionElementProvider { + + @Override + public FallbackIndicationElement parse(XmlPullParser parser, int initialDepth, XmlEnvironment xmlEnvironment) + throws XmlPullParserException, IOException, SmackParsingException { + return FallbackIndicationElement.INSTANCE; + } +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/package-info.java new file mode 100644 index 000000000..ea9827989 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/package-info.java @@ -0,0 +1,22 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Smack's API for XEP-0428: Fallback Indication. + * Element Providers. + */ +package org.jivesoftware.smackx.fallback_indication.provider; diff --git a/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers b/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers index d594578a4..d97f52ce5 100644 --- a/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers +++ b/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers @@ -299,6 +299,13 @@ org.jivesoftware.smackx.message_fastening.provider.FasteningElementProvider + + + fallback + urn:xmpp:fallback:0 + org.jivesoftware.smackx.fallback_indication.provider.FallbackIndicationElementProvider + + query diff --git a/smack-experimental/src/test/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationTest.java b/smack-experimental/src/test/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationTest.java new file mode 100644 index 000000000..342e783b5 --- /dev/null +++ b/smack-experimental/src/test/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationTest.java @@ -0,0 +1,42 @@ +/** + * + * Copyright 2020 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.fallback_indication; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.MessageBuilder; + +import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement; + +import org.junit.jupiter.api.Test; + +public class FallbackIndicationTest { + + @Test + public void testFallbackIndicationElementFromMessageTest() { + Message messageWithoutFallback = MessageBuilder.buildMessage() + .build(); + assertNull(FallbackIndicationElement.fromMessage(messageWithoutFallback)); + + Message messageWithFallback = MessageBuilder.buildMessage() + .addExtension(new FallbackIndicationElement()) + .build(); + assertNotNull(FallbackIndicationElement.fromMessage(messageWithFallback)); + } +} From 321c91c264887eabda10a63a66906c1a637bd8b3 Mon Sep 17 00:00:00 2001 From: Florian Schmaus Date: Wed, 13 May 2020 22:20:32 +0200 Subject: [PATCH 3/7] [build] Introduce bouncyCastleVersion variable and use it Also bumps bouncy castle to 1.65. --- build.gradle | 1 + smack-core/build.gradle | 2 +- smack-openpgp/build.gradle | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 76cf80d61..dd3e1bf57 100644 --- a/build.gradle +++ b/build.gradle @@ -116,6 +116,7 @@ allprojects { ].collect { project(it) } junitVersion = '5.6.0' commonsIoVersion = '2.6' + bouncyCastleVersion = '1.65' if (project.hasProperty("useSonatype")) { useSonatype = project.getProperty("useSonatype").toBoolean() } else { diff --git a/smack-core/build.gradle b/smack-core/build.gradle index acbbba065..9a8bd757d 100644 --- a/smack-core/build.gradle +++ b/smack-core/build.gradle @@ -18,7 +18,7 @@ dependencies { // 'implementation' here since there is no need to shadow it // outside of the fixtures compilation classpath. That is, no test // should ever setup Bouncy Castle as security provider explicitly. - testFixturesImplementation 'org.bouncycastle:bcprov-jdk15on:1.64' + testFixturesImplementation "org.bouncycastle:bcprov-jdk15on:${bouncyCastleVersion}" testFixturesImplementation 'org.apache.commons:commons-lang3:3.10' testFixturesApi "org.jxmpp:jxmpp-jid:$jxmppVersion:tests" diff --git a/smack-openpgp/build.gradle b/smack-openpgp/build.gradle index b9e90d9c0..23d15a366 100644 --- a/smack-openpgp/build.gradle +++ b/smack-openpgp/build.gradle @@ -10,7 +10,7 @@ dependencies { api 'org.pgpainless:pgpainless-core:0.0.1-alpha11' - testImplementation "org.bouncycastle:bcprov-jdk15on:1.65" + testImplementation "org.bouncycastle:bcprov-jdk15on:${bouncyCastleVersion}" testFixturesApi(testFixtures(project(":smack-core"))) testCompile group: 'commons-io', name: 'commons-io', version: "$commonsIoVersion" From afa42a8b4105a969ef1c40df0009d510510ec93a Mon Sep 17 00:00:00 2001 From: adiaholic Date: Tue, 28 Apr 2020 13:56:24 +0530 Subject: [PATCH 4/7] Remove `TODO:method should not throw any exception but currently does` `mgr.getNode(...)` method is not supposed to throw any type of exception. It threw two kinds of exceptions: `NotConnectedException` and `SmackException`. By using `ThreadedDummyConnection.newInstance()` method, `NotConnectedException` can be removed. And `SmackException` can be removed by correctly building the DiscoverInfo packet. --- .../smackx/pubsub/ConfigureFormTest.java | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/pubsub/ConfigureFormTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/pubsub/ConfigureFormTest.java index 320acba82..f350bb1ab 100644 --- a/smack-extensions/src/test/java/org/jivesoftware/smackx/pubsub/ConfigureFormTest.java +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/pubsub/ConfigureFormTest.java @@ -79,23 +79,25 @@ public class ConfigureFormTest extends SmackTestSuite { } @Test - public void getConfigFormWithTimeout() throws XMPPException, InterruptedException { - ThreadedDummyConnection con = new ThreadedDummyConnection(); + public void getConfigFormWithTimeout() throws XMPPException, InterruptedException, SmackException, IOException { + ThreadedDummyConnection con = ThreadedDummyConnection.newInstance(); PubSubManager mgr = new PubSubManager(con, PubSubManagerTest.DUMMY_PUBSUB_SERVICE); - DiscoverInfoBuilder info = DiscoverInfo.builder("disco-result"); + DiscoverInfoBuilder info = DiscoverInfo.builder("disco-result") + .ofType(IQ.Type.result) + .from(PubSubManagerTest.DUMMY_PUBSUB_SERVICE); + Identity ident = new Identity("pubsub", null, "leaf"); info.addIdentity(ident); DiscoverInfo discoverInfo = info.build(); con.addIQReply(discoverInfo); + Node node = mgr.getNode("princely_musings"); + + SmackConfiguration.setDefaultReplyTimeout(100); + con.setTimeout(); + assertThrows(SmackException.class, () -> { - // TODO: This method should not throw any exception but currently does. - Node node = mgr.getNode("princely_musings"); - - SmackConfiguration.setDefaultReplyTimeout(100); - con.setTimeout(); - node.getNodeConfiguration(); }); } From d903184ee27878c8e03255ff17ecac74efabe23c Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Wed, 13 May 2020 22:32:18 +0200 Subject: [PATCH 5/7] Quick typo fix: s/isntead/instead/g --- .../src/main/java/org/jivesoftware/smack/packet/Stanza.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/smack-core/src/main/java/org/jivesoftware/smack/packet/Stanza.java b/smack-core/src/main/java/org/jivesoftware/smack/packet/Stanza.java index 15c82127e..ee9377d1a 100644 --- a/smack-core/src/main/java/org/jivesoftware/smack/packet/Stanza.java +++ b/smack-core/src/main/java/org/jivesoftware/smack/packet/Stanza.java @@ -380,7 +380,7 @@ public abstract class Stanza implements StanzaView, TopLevelStreamElement { * @param elementName the XML element name of the extension. (May be null) * @param namespace the XML element namespace of the extension. * @return the extension, or null if it doesn't exist. - * @deprecated use {@link #getExtension(Class)} or {@link #getExtensionElement(String, String)} isntead. + * @deprecated use {@link #getExtension(Class)} or {@link #getExtensionElement(String, String)} instead. */ // TODO: Remove in Smack 4.5. @SuppressWarnings("unchecked") From d6c1018b47be4d8d204b310f16fea5205d8401a5 Mon Sep 17 00:00:00 2001 From: Florian Schmaus Date: Thu, 14 May 2020 17:11:19 +0200 Subject: [PATCH 6/7] [xdata] Remove FormWriter The FormWriter interface was a left over from the initial design of the reworked API, but is no longer required. --- .../smackx/xdata/form/FillableForm.java | 3 +-- .../smackx/xdata/form/FormWriter.java | 25 ------------------- 2 files changed, 1 insertion(+), 27 deletions(-) delete mode 100644 smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormWriter.java diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java index be562689f..39b1f4efd 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java @@ -39,7 +39,7 @@ import org.jxmpp.jid.util.JidUtil; import org.jxmpp.stringprep.XmppStringprepException; import org.jxmpp.util.XmppDateTime; -public class FillableForm extends FilledForm implements FormWriter { +public class FillableForm extends FilledForm { private final Set requiredFields; @@ -212,7 +212,6 @@ public class FillableForm extends FilledForm implements FormWriter { write(filledFormField); } - @Override public final void write(FormField filledFormField) { if (filledFormField.getType() == FormField.Type.fixed) { throw new IllegalArgumentException(); diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormWriter.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormWriter.java deleted file mode 100644 index 5e4e97cb1..000000000 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormWriter.java +++ /dev/null @@ -1,25 +0,0 @@ -/** - * - * Copyright 2020 Florian Schmaus - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.jivesoftware.smackx.xdata.form; - -import org.jivesoftware.smackx.xdata.FormField; - -public interface FormWriter { - - void write(FormField field); - -} From c5212c20b610e64eab125990c9fa67ee65e79864 Mon Sep 17 00:00:00 2001 From: Florian Schmaus Date: Thu, 14 May 2020 17:11:51 +0200 Subject: [PATCH 7/7] [xdata] Rename FormReader.read(String) to getField(String) Now that FormWriter, with its write() method, is gone, there is no reason the FormReader method should still be named read(). Renaming to getField() as this is what DataForm also uses. --- .../smackx/pubsub/form/ConfigureFormReader.java | 2 +- .../smackx/xdata/form/FillableForm.java | 4 ++-- .../jivesoftware/smackx/xdata/form/FilledForm.java | 6 +----- .../jivesoftware/smackx/xdata/form/FormReader.java | 14 +++++++------- 4 files changed, 11 insertions(+), 15 deletions(-) diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/pubsub/form/ConfigureFormReader.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/pubsub/form/ConfigureFormReader.java index 0184c41d8..865c3e834 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/pubsub/form/ConfigureFormReader.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/pubsub/form/ConfigureFormReader.java @@ -90,7 +90,7 @@ public interface ConfigureFormReader extends FormReader { * @return List of the whitelist */ default List getChildrenAssociationWhitelist() { - FormField formField = read(ConfigureNodeFields.children_association_whitelist.getFieldName()); + FormField formField = getField(ConfigureNodeFields.children_association_whitelist.getFieldName()); if (formField == null) { Collections.emptyList(); } diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java index 39b1f4efd..62fd32540 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java @@ -243,13 +243,13 @@ public class FillableForm extends FilledForm { } @Override - public FormField read(String fieldName) { + public FormField getField(String fieldName) { FormField filledField = filledFields.get(fieldName); if (filledField != null) { return filledField; } - return super.read(fieldName); + return super.getField(fieldName); } public DataForm getDataFormToSubmit() { diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java index baa768f39..7624eab80 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java @@ -43,7 +43,7 @@ public abstract class FilledForm implements FormReader { } @Override - public FormField read(String fieldName) { + public FormField getField(String fieldName) { return dataForm.getField(fieldName); } @@ -74,10 +74,6 @@ public abstract class FilledForm implements FormReader { return dataForm.hasField(fieldName); } - public FormField getField(String fieldName) { - return dataForm.getField(fieldName); - } - protected FormField getFieldOrThrow(String fieldName) { FormField formField = getField(fieldName); if (formField == null) { diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormReader.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormReader.java index 6a04fff46..493abd25a 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormReader.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormReader.java @@ -30,10 +30,10 @@ import org.jxmpp.util.XmppDateTime; public interface FormReader { - FormField read(String fieldName); + FormField getField(String fieldName); default String readFirstValue(String fieldName) { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return null; } @@ -41,7 +41,7 @@ public interface FormReader { } default List readValues(String fieldName) { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return Collections.emptyList(); } @@ -49,7 +49,7 @@ public interface FormReader { } default List readStringValues(String fieldName) { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return Collections.emptyList(); } @@ -58,7 +58,7 @@ public interface FormReader { } default Boolean readBoolean(String fieldName) { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return null; } @@ -67,7 +67,7 @@ public interface FormReader { } default Integer readInteger(String fieldName) { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return null; } @@ -76,7 +76,7 @@ public interface FormReader { } default Date readDate(String fieldName) throws ParseException { - FormField formField = read(fieldName); + FormField formField = getField(fieldName); if (formField == null) { return null; }