Ninja Plugins

Client Sessions

These session providers allow you to create all sorts of connections.

Establishes raw TCP connection to a remote or local server. Unlike most terminal applications, IO Ninja also lets you control details like the local interface, local port, graceful disconnect vs. TCP reset and so on.

Establishes an SSH-over-TCP connection to a remote or local server. You can tweak the SSH channel type, process type, and requested PTY; SSH authentication by username/password.

Open a UDP port, send packets to any destination, including broadcast, and examine replies arriving to it from (possibly) multiple nodes.

Use this plugin to work with devices attached to your computer via serial port. It's a serial terminal... that came from the future. Seriously, we published the first alpha version in 2034. It was awesome.

Allows you to connect to named pipes, work with non-standard devices, or dump incoming data to a file on disk.

Server Sessions

These session providers allow you to accept incoming connections.

Counterpart of TCP Connection plugin: listens for incoming connections to a TCP server.

Listens for incoming connections to a named pipe server. Microsoft Windows only.

It's a man in the middle: Listens on a local TCP port, when connection is accepted, attempts to establish a secondary connection to a local or remote server. After that passes data between client and server sides. Lets you control details of TCP connections.

Monitor Sessions

These session providers allow you to intercept data and monitor IO activity of other applications.

PCap-based network sniffer, decodes basic protocols of TCP/IP stack.

Intercepts serial communications performed by other applications on you PC. On Windows requires Tibbo Device Monitor Service (included in the installation package).

Uses PCap to intercept TCP communications and builds a clean data flow log (just like you see in TCP Connection/TCP Listener sessions).

Uses PCap to intercept UDP communications and builds a clean data flow log (just like you see in UDP Socket session).

Listens for incoming connections to a named pipe server. Microsoft Windows only.


These transport-independent plugins allow extending functionality of existing sessions.

Immediately transmits all incoming data back. Useful for testing or as base for a more advanced layer plugin.

Allows you to send and receive files using XModem protocol -- over any transport, not just serial!

  • Client Sessions
  • Server Sessions
  • Monitor Sessions
  • Layers

This turns IO Ninja into a raw TCP terminal. It lets you connect to other network nodes, send carefully crafted packets, and analyze any replies you get.

If you're ever curious as to exactly how a certain Web server reacts to a malformed packet, you no longer need to wonder -- try and see for yourself.

There are many terminals that are capable of establishing a TCP connection to a local or remote server. Fewer allow you to prepare packets before transmission. Fewer still let you do this in binary mode, with a hex-editor. But none provide log and transmit capabilities as powerful at dealing with binary data as IO Ninja.

Binary data aside, you can fully control anything about the TCP socket:

  • Local interface
  • Local port
  • Whether or not to use Nagle's algorithm
  • Whether to close the connection gracefully or drop it with a TCP reset

Turns IO Ninja into an SSH client. Switch to terminal view and work with your server just like you would with any other SSH client, or use IO Ninja's extensive data handling capabilities.

The SSH Channel plugin lets you choose SSH channel type, SSH process type and PTY type, and gives you full control over the underlying TCP socket, just like the TCP Connection plugin does.

Currently supports username/password authentication only.

The UDP Socket plugin allows you to perform communication without having to worry about connections. A single open UDP socket can communicate with a whole group of remote nodes at the same time. This ability can be used, for example, to implement a scanning feature in applications (device auto-discovery).

Another example where the UDP socket can come in handy is when your device hasn't been assigned an IP address: Your only option to reach it is with a UDP broadcast.

These are all things which cannot be done with an ordinary terminal program, even when it "supports UDP". This is because the "support" is normally for connection-oriented UDP, as opposed to the connectionless mode provided by the IO Ninja UDP Socket plugin.

When working with serial devices, you often need to send commands and see what reply you get from the device. This plugin works like a traditional serial terminal... beefed up with the Ninja Scroll Engine and the Binary Packet builder.

The serial plugin also lets you tune out the noise, or listen to it: All status line, control line and serial setting changes get recorded in the log -- nothing gets lost. But you are free to choose whether to display them or filter them out, leaving a clean and readable log sheet.

The most generic IO primitive in most operating systems is a file. "File" here doesn't mean a literal file on a disk, but rather an abstract device which supports read & write operations. Special capabilities of specific device type are normally exposed via so-called ioctls. IO Ninja thinks of a file as of a generic IO stream with no special capabilities. Use this plugin for:

  • Pipe communications
  • Talking to a custom device driver
  • Dumping all data received by another connection to a file on disk (see Session Linking)

This plugin is server-side counterpart of TCP Connection. It is used to accept incoming connections over TCP.

Most terminal programs can't do this: They can only create outgoing connections. Actually receiving a connection is often the most straightforward way to troubleshoot the client side of your product.

The TCP Listener plugin gives you full control over the underlying TCP Socket (local interface, TCP disconnect type etc).

Under Microsoft Windows, applications often perform inter-process communication using named pipes. The Pipe Listener plugin lets you create a server-side pipe for the client to connect to, for testing named pipe communications. For obvious reasons, this plugin is only available on Microsoft Windows.

TCP Proxy is a man-in-the-middle for TCP connections. Just like Sniffer, it is intended for intercepting data being passed between 2 TCP nodes.

You set it up with a specific interface and TCP port to listen on and a specific destination address to connect to. Whenever a client connects to the server side of TCP Proxy, the client side establishes a secondary connection to the specified desintation. Then TCP Proxy keeps passing data back and forth between its two peers logging everything in the process.

In some situations, this proxy approach is better than a sniffer.

Using a sniffer for intercepting the packets of a connection you want to monitor isn't always easy. For example, if it's TCP over Wi-Fi, PCap doesn't cut it. Or it could be regular Ethernet networking, but with both nodes outside of your local network segment, beyond the reach of a sniffer. Redirecting TCP communications through IO Ninja TCP proxy solves these problems.

Another reason to use a proxy instead of a sniffer is clarity of representation. When you use a TCP proxy, the log looks just like when you're using the TCP Connection plugin, as opposed to the packet-based representation generated by a sniffer.

There are so many IP sniffers, free and commercial, open-source and proprietary. Wikipedia dedicates the whole article for comparing network sniffers, and it doesn't fit on one page, either. What could be improved here?

Well, there's something that most other sniffers don't have, and that is an easy-to-follow single-view log sheet that plays well with binary data -- courtesy of the Ninja Scroll Logging Engine.

The Network Sniffer plugin also lets you to inject your own custom-made packets, which in conjunction with the Jancy packet template feature opens a whole new range of low-level testing and security audit capabilities.

Under the hood, the Network Sniffer plugin is powered by Pcap, an industry-standard open-source cross-platform packet capture driver. It's the same driver behind WireShark and many other excellent sniffers.

The Serial Monitor plugin lets you monitor serial port activity, including open, close, serial setting change, control/status line change and of course, the actual data flowing through the port.

Log entries you don't care about -- for example, control or status line change notifications -- can be hidden to keep the log clean. When you do need them, it's easy to display them again.

Currently this plugin is only available on Microsoft Windows.

One thing which is usually lacking in packet-based TCP sniffers is the ability to conveniently follow the conversation between the nodes. Sure, there might be a "Re-create Conversation" or a similary function -- but you still need to capture packets first and post-process the log later. Besides, this re-created conversation might be not so easy to use if binary data is involved.

IO Ninja provides an elegant way to see just the data and nothing else. Specify an interface to capture packets on, specify the filter in the form of address (or just port) and forget about packets! You will receive a clean log of data exchange reconstructed from the captured packets behind the scene - and in real time (no capture-first-re-create-conversation-later). The end result will look just like the one you see in TCP Connection plugin or TCP Listener plugin.

And of course, since this log is powered by our binary-oriented Ninja Scroll Logging Engine, you are free to use all the advanced logging features such as merging packets, switching between hex-view and plain text, inspecting data offsets and lengths, searching for binary patterns (even when they span across packet boundaries) and so on.

Under the hood, the TCP Flow Monitor plugin is powered by PCap, an industry-standard open-source cross-platform packet capture driver.

This plugin is a UDP counterpart of TCP Flow Monitor -- a specialized UDP sniffer which allows you to concentrate on the data exchange between the UDP nodes, without digging into the details hidden deep down the protocol stack.

Just like in TCP Flow Monitor you specify the filter using the address (or just UDP port) and then receive a clean log of UDP conversation just like the one produced by UDP Socket plugin.

Under Microsoft Windows, applications, services and drivers often perform IPC (inter-process communication) using named pipes. The problem is, there are no well-known tools to sniff/monitor named pipe communications, making it rather difficult to debug. Pipe Monitor is the missing piece of the puzzle - it lets you see what is flowing through named pipes.

Since in Windows there are many named pipes performing communications at the same time, you need to somehow filter only the pipes you are interested in. Pipe Monitor plugins lets you do just that by specifing a pipe name wildcard - you will only see the data flowing through the pipes with matching names.

The Echo plugin is quite possibly the simplest layer you could imagine. Whatever is received, is sent back immediately (hence, the tennis ball on the icon).

In fact, here's the entire code for the plugin:

class EchoLayer: doc.Layer
    construct (doc.PluginHost* pluginHost)
        basetype.construct (pluginHost);   
        pluginHost.m_log.attachListener (
            onLogRecord @ pluginHost.m_mainThreadScheduler

    onLogRecord (
        uint64_t timestamp,
        uint_t recordCode,
        void const* p,
        size_t size
        if (recordCode == log.StdRecordCode.Rx)
            try transmit (p, size);

And that's it!

As simple as it looks, it's pretty useful for testing purposes. Also, it might be your starting point for building a more sophisiticated testing utility.

The XModem plugin implements transmission and reception of files using XModem protocol. Since it is implemented in form of layer, you can use XModem to transfer files over any transport, not just Serial.


DS110x Family