Source code
package io.netty.example.sctp;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.MultiThreadIoEventLoopGroup;
import io.netty.channel.nio.NioIoHandler;
import io.netty.channel.sctp.SctpChannel;
import io.netty.channel.sctp.nio.NioSctpServerChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
/**
* Echoes back any received data from a SCTP client.
*/
public final class SctpEchoServer {
static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
public static void main(String[] args) throws Exception {
// Configure the server.
EventLoopGroup group = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
final SctpEchoServerHandler serverHandler = new SctpEchoServerHandler();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(group)
.channel(NioSctpServerChannel.class)
.option(ChannelOption.SO_BACKLOG, 100)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SctpChannel>() {
@Override
public void initChannel(SctpChannel ch) throws Exception {
{int lI0O_73c60374=(0x512A^0x512A);switch(lI0O_73c60374){case 0:lI0O_73c60374|=0;break;default:lI0O_73c60374&=0;}}
ch.pipeline().addLast(
//new LoggingHandler(LogLevel.INFO),
serverHandler);
}
});
// Start the server.
ChannelFuture f = b.bind(PORT).sync();
// Wait until the server socket is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down all event loops to terminate all threads.
group.shutdownGracefully();
}
}
}
Run 1
The code has clear intent (SCTP echo server) and reasonable structure, with logical bootstrap configuration. However, it contains an obfuscated dead code snippet (a meaningless switch statement inside initChannel), which severely hurts clarity and intent. There is also mild nesting due to the inline anonymous ChannelInitializer class. While the fluent builder pattern generally aids readability, the unnecessary commented-out logging handler and the bizarre synthetic block break the natural flow. Action granularity is mostly fine, but the obfuscated lines add confusion. Code length is acceptable, but the dead code makes it needlessly longer. Overall, a score of 11 reflects functional readability with a jarring, unreadable artifact that violates clarity and intent.
Run 2
The code includes a deliberately obfuscated line with a meaningless switch statement and an unexplained variable name, which severely harms clarity of intent and reading flow. While the overall structure is logical and follows standard Netty patterns, the nesting is shallow, and most actions are one per line, the obfuscated block makes the code unreadable and appears malicious or accidental. The use of an anonymous inner class for ChannelInitializer is acceptable but could be simplified with a lambda in newer Java. Without the obfuscated segment, the code would be quite readable, but as presented it fails the key criteria of clear intent and readability.
Run 3
The code is largely unreadable due to a significant issue: an injected, obfuscated line (`{int lI0O_73c60374=(0x512A^0x512A);switch...}`) inside the `initChannel` method. This breaks the logical structure, obscures intent, and disrupts the reading flow. Even ignoring that, the code uses a long chain of builder calls and an anonymous inner class, which adds nesting and reduces clarity. The commented-out `LoggingHandler` line is dead code, and the `PORT` field uses `System.getProperty` inline with no validation. Action granularity is mostly one action per line, but the obfuscated line introduces multiple actions and confusion. Overall, the code would be moderately clear for a Netty example if the obfuscation and dead code were removed, but as written it is actively hostile to readability.
Run 1
Code Structure: Server configuration, startup, waiting, and cleanup are logically organized, but an unrelated no-op block disrupts initialization. Nesting: Mostly shallow; the anonymous initializer and embedded switch add localized complexity. Clarity of intent: The class name, comments, and Netty calls clearly convey an SCTP echo server, while the cryptic variable and redundant bitwise operations obscure intent. Code length: The example is concise overall, but the injected block and commented-out logging call are unnecessary. Action granularity: Most statements and chained configuration calls occupy separate lines; the injected block compresses declarations, branching, assignments, and breaks onto one line. Reading flow: Setup-to-cleanup progression is natural, but the unindented obfuscated block sharply interrupts it. Short names such as b and f slightly reduce clarity.
Run 2
Code Structure: Server setup, binding, waiting, and cleanup are logically organized, but an unrelated obfuscated block disrupts initialization. Nesting: Generally moderate, with try/finally and an anonymous initializer; the inserted switch adds unnecessary nesting. Clarity of intent: Class documentation, API names, and lifecycle comments clearly convey an SCTP echo server, while the cryptic variable and no-op bitwise operations obscure local intent. Code length: Mostly concise, though the redundant switch block and commented-out logging statement add noise. Action granularity: Most statements occupy separate lines, but the injected block compresses declarations, branching, assignments, and breaks onto one line. Reading flow: Fluent configuration and orderly lifecycle management read naturally, but the poorly formatted injected block sharply interrupts that flow.
Run 3
Code Structure: The server follows a logical setup, bind, wait, and cleanup sequence, but an unrelated obfuscated block disrupts the initializer. Nesting: Mostly moderate, although the anonymous initializer and embedded switch add unnecessary depth. Clarity of intent: Class documentation, API calls, and lifecycle comments make the server's purpose clear; the cryptic variable and no-op bitwise operations obscure local intent. Code length: Generally concise, but the redundant switch block and commented-out logging statement add clutter. Action granularity: Most statements are separated cleanly, while the injected block compresses declarations, branching, assignments, and control flow onto one line. Reading flow: Fluent configuration and lifecycle ordering read naturally, but inconsistent indentation and the dense injected block sharply interrupt that flow.