packages/xnio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: packages:10cd1d947b8c7f6a7c9f188ed81567a416f59da2
Branches Tags
packages:main
..
compare: packages:45576546134ed86302bf5397b493b7ceae153aa3
Branches Tags
packages:main

No commits in common. "10cd1d947b8c7f6a7c9f188ed81567a416f59da2" and "45576546134ed86302bf5397b493b7ceae153aa3" have entirely different histories.
10cd1d947b ... 4557654613

4 changed files with 1 additions and 421 deletions
Show Stats Expand all files Collapse all files

13
0002-skip-connect-timeout.patch
View File

@ -1,13 +0,0 @@
diff -urN ./nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java ./nio-impl-new/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java
--- ./nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java 2016-08-01 23:56:53.000000000 +0800
+++ ./nio-impl-new/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java 2021-08-06 19:05:26.958856896 +0800
@@ -277,7 +277,8 @@
final IoFuture<ConnectedStreamChannel> anotherChannel = xnioWorker.connectStream(bindAddress, null, OptionMap.EMPTY);
assertNotNull(anotherChannel.get());
anotherChannel.get().close();
- } finally {
+ } catch (Exception e){
+ } finally {
streamServer.close();
}
}

27
0003-skip-Future-cancel-test-case.patch
View File

@ -1,27 +0,0 @@
diff -Nur a/nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java b/nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java
--- a/nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java 2022-08-23 10:11:22.038452259 +0800
+++ b/nio-impl/src/test/java/org/xnio/nio/test/XnioWorkerTestCase.java 2022-08-23 10:13:59.801010856 +0800
@@ -37,6 +37,7 @@
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.Ignore;
import org.xnio.ChannelListener;
import org.xnio.IoFuture;
import org.xnio.LocalSocketAddress;
@@ -432,6 +433,7 @@
bindAddress2, connectedStreamChannel2.get().getLocalAddress());
}
+ @Ignore
@Test
public void cancelAcceptStreamConnection() throws CancellationException, IOException {
final XnioWorker xnioWorker = xnio.createWorker(OptionMap.EMPTY);
@@ -462,6 +464,7 @@
}
}
+ @Ignore
@Test
public void cancelAcceptTcpStream() throws CancellationException, IOException {
final XnioWorker xnioWorker = xnio.createWorker(OptionMap.EMPTY);

364
backport-CVE-2023-5685.patch
View File

@ -1,364 +0,0 @@
From a2fce38d48cca947ea42ee3bead08dd138b42c01 Mon Sep 17 00:00:00 2001
From: Flavia Rainone <frainone@redhat.com>
Date: Fri, 14 Oct 2022 17:00:46 -0300
Subject: [PATCH] [XNIO-423] CVE-2023-5685 Move the recursion in NotifierState
to a iteration, preventing a stack overflow exception when the chain of
notifier states becomes problematically big
Signed-off-by: Flavia Rainone <frainone@redhat.com>
Origin:
https://github.com/xnio/xnio/commit/a2fce38d48cca947ea42ee3bead08dd138b42c01
---
.../main/java/org/xnio/AbstractIoFuture.java | 238 ++++++++++++++----
1 file changed, 187 insertions(+), 51 deletions(-)
diff --git a/api/src/main/java/org/xnio/AbstractIoFuture.java b/api/src/main/java/org/xnio/AbstractIoFuture.java
index 6118a0c7e3..030336b918 100644
--- a/api/src/main/java/org/xnio/AbstractIoFuture.java
+++ b/api/src/main/java/org/xnio/AbstractIoFuture.java
@@ -74,6 +74,141 @@ IOException getException() {
}
}
+ private static abstract class NestedState<T> extends State<T> {
+ private final State<T> next;
+
+ public NestedState(final State next) {
+ this.next = next;
+ }
+
+ /**
+ * Perform any actions that need to be executed when future is done, delegation of done notification to next is
+ * taken care of by invoker.
+ *
+ * @param future the future
+ * @param result the result
+ */
+ protected abstract void doNotifyDone(AbstractIoFuture<T> future, T result);
+
+ @Override
+ public void notifyDone(AbstractIoFuture<T> future, T result) {
+ doNotifyDone(future, result);
+ if (next instanceof NestedState) {
+ NestedState<T> current = this;
+ do {
+ current = (NestedState<T>) current.next;
+ current.doNotifyDone(future, result);
+ } while (current.next instanceof NestedState);
+ current.next.notifyDone(future, result);
+ } else {
+ next.notifyDone(future, result);
+ }
+
+ }
+
+ /**
+ * Perform any actions that need to be done at this state for handling failure, delegation of failure
+ * notification to next is taken care of by invoker
+ *
+ * @param future the future
+ * @param exception the failure
+ */
+ protected abstract void doNotifyFailed(AbstractIoFuture<T> future, IOException exception);
+
+ @Override
+ public void notifyFailed(AbstractIoFuture<T> future, IOException exception) {
+ doNotifyFailed(future, exception);
+ if (next instanceof NestedState) {
+ NestedState<T> current = this;
+ do {
+ current = (NestedState<T>) current.next;
+ current.doNotifyFailed(future, exception);
+ } while (current.next instanceof NestedState);
+ current.next.notifyFailed(future, exception);
+ } else {
+ next.notifyFailed(future, exception);
+ }
+ }
+
+ /**
+ * Perform any actions that need to be done at this state for handling cancellation, delegation of cancellation
+ * notification to next is taken care of by invoker
+ *
+ * @param future the future
+ */
+ protected abstract void doNotifyCancelled(AbstractIoFuture<T> future);
+
+
+
+ @Override
+ public void notifyCancelled(AbstractIoFuture<T> future) {
+ doNotifyCancelled(future);
+ if (next instanceof NestedState) {
+ NestedState<T> current = this;
+ do {
+ current = (NestedState<T>) current.next;
+ current.doNotifyCancelled(future);
+ } while (current.next instanceof NestedState);
+ current.next.notifyCancelled(future);
+ } else {
+ next.notifyCancelled(future);
+ }
+ }
+
+ /**
+ * Perform any actions that need to be done at this state for cancellation. Delegation of cancellation to next
+ * is taken care of by invoker.
+ */
+ protected abstract void doCancel();
+
+ /**
+ * Just delegate cancel() to first next state in the nested chain that is not a NestedState.
+ */
+ @Override
+ public void cancel() {
+ doCancel();
+ if (next instanceof NestedState) {
+ NestedState<T> current = this;
+ do {
+ current = (NestedState<T>) current.next;
+ current.doCancel();
+ } while (current.next instanceof NestedState);
+ current.next.cancel();
+ } else {
+ next.cancel();
+ }
+ }
+
+ /**
+ * Return {@code true} to indicate that, at this state, cancel is requested. If returns false, invoker
+ * will check for inner next states in the chain until it finds a positive result or the final state in the
+ * chain.
+ *
+ * @return {@code true} to indicate that cancel is requested; {@code false} to delegate response to nested
+ * state.
+ */
+ protected abstract boolean isCancelRequested();
+
+ @Override
+ public boolean cancelRequested() {
+ if (isCancelRequested()) {
+ return true;
+ }
+ if (next instanceof NestedState) {
+ NestedState<T> current = this;
+ do {
+ current = (NestedState<T>) current.next;
+ if (current.isCancelRequested()) {
+ return true;
+ }
+ } while (current.next instanceof NestedState);
+ return current.next.cancelRequested();
+ } else {
+ return next.cancelRequested();
+ }
+ }
+ }
+
static final class InitialState<T> extends State<T> {
Status getStatus() {
@@ -229,13 +364,12 @@ boolean cancelRequested() {
}
}
- static final class NotifierState<T, A> extends State<T> {
- final State<T> next;
+ static final class NotifierState<T, A> extends NestedState<T> {
final Notifier<? super T, A> notifier;
final A attachment;
NotifierState(final State<T> next, final Notifier<? super T, A> notifier, final A attachment) {
- this.next = next;
+ super(next);
this.notifier = notifier;
this.attachment = attachment;
}
@@ -244,40 +378,41 @@ Status getStatus() {
return Status.WAITING;
}
- void notifyDone(final AbstractIoFuture<T> future, final T result) {
+ @Override
+ protected void doNotifyDone(final AbstractIoFuture<T> future, final T result) {
doNotify(future);
- next.notifyDone(future, result);
}
- void notifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
+ @Override
+ protected void doNotifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
doNotify(future);
- next.notifyFailed(future, exception);
}
- void notifyCancelled(final AbstractIoFuture<T> future) {
+ @Override
+ protected void doNotifyCancelled(final AbstractIoFuture<T> future) {
doNotify(future);
- next.notifyCancelled(future);
}
- void cancel() {
- next.cancel();
+
+ @Override
+ protected void doCancel() {
}
private void doNotify(final AbstractIoFuture<T> future) {
future.runNotifier(new NotifierRunnable<T, A>(notifier, future, attachment));
}
- boolean cancelRequested() {
- return next.cancelRequested();
+ @Override
+ protected boolean isCancelRequested() {
+ return false;
}
}
- static final class WaiterState<T> extends State<T> {
- final State<T> next;
+ static final class WaiterState<T> extends NestedState<T> {
final Thread waiter;
WaiterState(final State<T> next, final Thread waiter) {
- this.next = next;
+ super(next);
this.waiter = waiter;
}
@@ -285,36 +420,35 @@ Status getStatus() {
return Status.WAITING;
}
- void notifyDone(final AbstractIoFuture<T> future, final T result) {
+ @Override
+ protected void doNotifyDone(final AbstractIoFuture<T> future, final T result) {
LockSupport.unpark(waiter);
- next.notifyDone(future, result);
}
- void notifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
+ @Override
+ protected void doNotifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
LockSupport.unpark(waiter);
- next.notifyFailed(future, exception);
}
- void notifyCancelled(final AbstractIoFuture<T> future) {
+ @Override
+ protected void doNotifyCancelled(final AbstractIoFuture<T> future) {
LockSupport.unpark(waiter);
- next.notifyCancelled(future);
}
- void cancel() {
- next.cancel();
- }
+ @Override
+ protected void doCancel() {}
- boolean cancelRequested() {
- return next.cancelRequested();
+ @Override
+ protected boolean isCancelRequested() {
+ return false;
}
}
- static final class CancellableState<T> extends State<T> {
- final State<T> next;
+ static final class CancellableState<T> extends NestedState<T> {
final Cancellable cancellable;
CancellableState(final State<T> next, final Cancellable cancellable) {
- this.next = next;
+ super(next);
this.cancellable = cancellable;
}
@@ -322,58 +456,60 @@ Status getStatus() {
return Status.WAITING;
}
- void notifyDone(final AbstractIoFuture<T> future, final T result) {
- next.notifyDone(future, result);
+ @Override
+ protected void doNotifyDone(final AbstractIoFuture<T> future, final T result) {
}
- void notifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
- next.notifyFailed(future, exception);
+ @Override
+ protected void doNotifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
}
- void notifyCancelled(final AbstractIoFuture<T> future) {
- next.notifyCancelled(future);
+ @Override
+ protected void doNotifyCancelled(final AbstractIoFuture<T> future) {
}
- void cancel() {
+ @Override
+ protected void doCancel() {
try {
cancellable.cancel();
} catch (Throwable ignored) {}
- next.cancel();
}
- boolean cancelRequested() {
- return next.cancelRequested();
+ @Override
+ protected boolean isCancelRequested() {
+ return false;
}
}
- static final class CancelRequestedState<T> extends State<T> {
- final State<T> next;
+ static final class CancelRequestedState<T> extends NestedState<T> {
CancelRequestedState(final State<T> next) {
- this.next = next;
+ super(next);
}
Status getStatus() {
return Status.WAITING;
}
- void notifyDone(final AbstractIoFuture<T> future, final T result) {
- next.notifyDone(future, result);
+ @Override
+ protected void doNotifyDone(final AbstractIoFuture<T> future, final T result) {
}
- void notifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
- next.notifyFailed(future, exception);
+ @Override
+ protected void doNotifyFailed(final AbstractIoFuture<T> future, final IOException exception) {
}
- void notifyCancelled(final AbstractIoFuture<T> future) {
- next.notifyCancelled(future);
+ @Override
+ protected void doNotifyCancelled(final AbstractIoFuture<T> future) {
}
- void cancel() {
+ @Override
+ protected void doCancel() {
// terminate
}
- boolean cancelRequested() {
+ @Override
+ protected boolean isCancelRequested() {
return true;
}
}

18
xnio.spec
View File

@ -1,6 +1,6 @@
Name: xnio
Version: 3.4.0
Release: 11
Release: 7
Summary: A simplified low-level I/O layer
License: ASL 2.0 and LGPLv2+
URL: http://www.jboss.org/xnio
@ -16,10 +16,6 @@ BuildRequires: mvn(org.jboss.logmanager:jboss-logmanager) mvn(org.jmock:jmock-ju
BuildRequires: mvn(org.wildfly.common:wildfly-common)
Patch0001: 0001-Disable-tests-use-TLSv1-protocol.patch
Patch0002: 0002-skip-connect-timeout.patch
Patch0003: 0003-skip-Future-cancel-test-case.patch
Patch3000: backport-CVE-2023-5685.patch
%description
XNIO is a simplified low-level I/O layer which can be used anywhere you are using NIO today.
@ -70,18 +66,6 @@ rm api/src/test/java/org/xnio/racecondition/ResumeReadsOnHandlingReadableChannel
%files help -f .mfiles-javadoc
%changelog
* Wed Nov 06 2024 yaoxin <yao_xin001@hoperun.com> - 3.4.0-11
- Fix CVE-2023-5685
* Tue Aug 23 2022 liyanan <liyanan32@h-partners.com> - 3.4.0-10
- skip cancelAcceptStreamConnection test case
* Thu Aug 11 2022 liyanan <liyanan32@h-partners.com> - 3.4.0-9
- skip cancelAcceptTcpStream test case
* Fri Aug 6 2021 Lu Weitao <luweitaobe@163.com> - 3.4.0-8
- skip tests when connect timeout
* Tue Feb 23 2021 lingsheng <lingsheng@huawei.com> - 3.4.0-7
- Disable tests use TLSv1 protocol