Forem: Ochi Daiki

TUI tool for generating packets of arbitrary input and monitoring packets!

Ochi Daiki — Fri, 09 May 2025 00:31:58 +0000

Hi! Today, I have a tool that I really want to introduce to you all.

It is a TUI tool that I am currently developing, and it has two functions.
The repository for the tool is https://github.com/ddddddO/packemon.

The first is the ability to generate and send packets!

Send generated packets to any network interfaces.
- You can specify the network interface with --interface flag. Default is eth0.
Packets of various protocols are supported.
- You can configure and generate arbitrary packets at each layer of the TCP/IP model.
- Details are in the README of the repository.

Second, you can monitor packets sent and received!

Monitor any network interfaces.
- You can specify network interface with --interface flag.
Can filter packets to be displayed.
- You can filter the values for each item (e.g. Dst, Proto, SrcIP.... . etc.) displayed in the listed packets.
Specified packets can be saved to pcapng file.
Packets of various protocols are supported.

Finally

This tool is a full scratch implementation of the protocol stack. When I tried to establish a connection with my own implementation of TCP 3-way-handshake with this tool, the kernel was sending TCP RST packets. So I have included a process to drop the RST packets sent using eBPF. Also, this is only supported on Linux.

Please see the README for more information! The README also includes instructions on how to use and install it.

If you use it I will be happy!

Want to output a tree in Go?

Ochi Daiki — Sat, 21 Oct 2023 08:15:43 +0000

I am sure that you have often used the tree command to output a tree of directories.
But have you ever wanted to output a tree of something other than your local directory?
There is a Go package that you should know about, and that is https://github.com/ddddddO/gtree. This is the perfect library to easily output a tree.

Here is a simple Go program that outputs a tree from the find command.

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"

    "github.com/ddddddO/gtree"
)

// Example:
// $ cd github.com/ddddddO/gtree
// $ find . -type d -name .git -prune -o -type f -print
// ./config.go
// ./node_generator_test.go
// ./example/like_cli/adapter/indentation.go
// ./example/like_cli/adapter/executor.go
// ./example/like_cli/main.go
// ./example/find_pipe_programmable-gtree/main.go
// ...
// $ find . -type d -name .git -prune -o -type f -print | go run example/find_pipe_programmable-gtree/main.go
// << See "Output:" below. >>
func main() {
    var (
        root *gtree.Node
        node *gtree.Node
    )
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        line := scanner.Text()              // e.g.) "./example/find_pipe_programmable-gtree/main.go"
        splited := strings.Split(line, "/") // e.g.) [. example find_pipe_programmable-gtree main.go]

        for i, s := range splited {
            if root == nil {
                root = gtree.NewRoot(s) // s := "."
                node = root
                continue
            }
            if i == 0 {
                continue
            }

            tmp := node.Add(s)
            node = tmp
        }
        node = root
    }

    if err := gtree.OutputProgrammably(os.Stdout, root); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    // Output:
    // .
    // ├── config.go
    // ├── node_generator_test.go
    // ├── example
    // │   ├── like_cli
    // │   │   ├── adapter
    // │   │   │   ├── indentation.go
    // │   │   │   └── executor.go
    // │   │   └── main.go
    // │   ├── find_pipe_programmable-gtree
    // │   │   └── main.go
    // │   ├── go-list_pipe_programmable-gtree
    // │   │   └── main.go
    // │   └── programmable
    // │       └── main.go
    // ├── file_considerer.go
    // ├── node.go
    // ├── node_generator.go
    // ├── .gitignore
    // ...
}

I was able to output a tree with the above program.
The program I introduced here was just a utility to display a tree of directories on the local PC after all.

However, do not be discouraged.
Developers who are not me have created CLI tools to output a tree of Amazon S3 and GCS buckets! You can find them in the following repositories.

⭐https://github.com/orangekame3/stree
⭐https://github.com/owlinux1000/gcstree

I had no idea of displaying a tree of cloud storage. Also, the aws s3 and gcloud storage commands do not have the functionality to display a tree.
I am sure you will be happy to use these CLI tools.

I got very good inspiration from these CLI tool developers. I am also very happy that they are using the gtree package!

If you want to tree output something, you may find https://github.com/ddddddO/gtree useful.

Thanks for reading!

Tree Maker __ Convert Markdown to tree!

Ochi Daiki — Fri, 18 Nov 2022 15:24:50 +0000

The link to this website is https://ddddddo.github.io/gtree/

Usage is as follows.

The symbols that can be used in Markdown are *, -, +, and #.
Use every two spaces to represent a hierarchy.

This website features.

The function to generate tree is written in Go and compiled to WebAssembly.
It uses ServiceWorker, so you can load it once and then enjoy it offline!

I provide not only website, but also CLI tool and Go package. These also have the ability to generate directories from markdown!
The repository is https://github.com/ddddddO/gtree
I'd love it if you'd star it!

Tree Maker

Ochi Daiki — Sat, 24 Sep 2022 16:52:14 +0000

https://ddddddo.github.io/gtree/

This page calls a function that outputs tree. This function is a Go package compiled as WebAssembly.
You can change the branches like in the image below.
Also, once loaded, you can enjoy offline!

Output tree🌳 or Make directories(files)📁 from Markdown or Programmatically

Ochi Daiki — Sat, 22 Jan 2022 13:33:13 +0000

repository

You can generate tree without directory, and output is JSON or YAML or TOML or tree command like.

Ochi Daiki — Sat, 20 Nov 2021 19:36:18 +0000

https://www.reddit.com/r/golang/comments/qxxju1/you_can_generate_tree_without_directory_and/?utm_source=share&utm_medium=mweb

Can generate a Tree by Golang!

Ochi Daiki — Thu, 21 Oct 2021 15:00:24 +0000

please go to https://github.com/ddddddO/gtree

There are three ways to generate tree (CLI, Package(1), Package(2)). They are explained below.

CLI and Package(1).

Given a Markdown file or format, the result of linux tree command is printed.

Hierarchy is represented by hyphen and indentation.

Indentation should be unified by one of the following.
・Tab (default)
・Two spaces (required: -ts)
・Four spaces (required: -fs)

Package(1)

You can customize branch format.

Package(2)

You can also generate a tree programmatically.
Markdown is irrelevant.
You can customize branch format.