mdnsforwarder

README

MDNSForwarder

This is an app which allows to forward MDNS messages between different networks. The primary intend is to forward MDNS queries through unicast addresses (like a VPN network).

It has been succesfully tested to run on an OpenWRT router using the mips processor connecting to a docker container network in Kubernetes.

Usage

mdnsforwarder --log-level DEBUG --config config.json

If no config path is specified the default (/etc/config/mdnsforwarder) is used.

Refer to the config.json for an example. The configuration options are:

• mdnsInterfaces: list of interfaces which should route mdnstraffic between each other
• listeners: Host/Port combination where unicast messages including mdns messages via UDP is expected
• targets: The list of targets where MDNS traffic from the local interfaces should be forwarded to.
• skip_own_ip: Defaults to true. If set to false, this will handle all messages which are also send by the own list and should only be used in special environments.

Installing on OpenWRT

The installation process on OpenWRT requires you to know the processor architecture of the device and pick out the correct executable. You can test this by downloading from the releases tab the executable and see if it runs. You require ssh access to the device for it to work.

To for example test if your device is arm64 compatible do the following:

wget -O mdnsforwarder https://github.com/cbrand/mdnsforwarder/releases/download/1.1.0/mdnsforwarder-arm64
chmod +x /root/mdnsforwarder
/root/mdnsforwarder --help

If you do not see an error message you have the right architecture.

Other more likely candidates for your router are

• mips

wget -O mdnsforwarder https://github.com/cbrand/mdnsforwarder/releases/download/1.1.0/mdnsforwarder-mips
chmod +x /root/mdnsforwarder
/root/mdnsforwarder --help

• mipsle

wget -O /root/mdnsforwarder https://github.com/cbrand/mdnsforwarder/releases/download/1.1.0/mdnsforwarder-mipsle
chmod +x /root/mdnsforwarder
/root/mdnsforwarder --help

Once you figure this out make a note where you have downloaded the executable and move it - if desired - to another location.

Afterwards you need to install it as a service. Add a new file in /etc/init.d/mdnsforwarder and add the following content:

#!/bin/sh /etc/rc.common
USE_PROCD=1
START=95
STOP=01
start_service() {
    procd_open_instance
    # The /root/mdnsforwarder must be adjusted to the folder where you downloaded it in.
    procd_set_param command /root/mdnsforwarder
    procd_close_instance
}

Additionally, make the script executable via chmod +x /etc/init.d/mdnsforwarder in your command line.

Make sure that you have the configuration of the mdnsforwarder added to /etc/config/mdnsforwarder for example with:

{
    "mdnsInterfaces": [
        "eth0",
        "eth1"
    ],
    "listeners": [
        "0.0.0.0:53531"
    ],
    "targets": [
        "remote:53531"
    ]
}

Afterwards enable and start the service:

/etc/init.d/mdnsforwarder enable
/etc/init.d/mdnsforwarder start

On restart the mdnsforwarder will now start automatically. You can also verify the process to run without a reboot by checking if it is there:

ps | grep mdnsforwarder

Availability

• The program is pulished as a self running go-executable for various platforms in the releases tab.
• To run it in a docker container, the image is published in Docker Hub with the image cbrand/mdnsforwarder.

Caveats

The remote MDNS traffic forwarding doesn't have any security. It doesn't encrypt any traffic and relies on protection from a lower layer (for example by utilizing a VPN). DO NOT USE THIS DIRECTLY OVER THE OPEN INTERNET.

License

The application is published via the MIT license.

Documentation

Index

• type Forwarder
  • func New(interfaces []*net.Interface, listenerIps []*net.UDPAddr, ...) Forwarder
• type ForwarderImpl
  • func (forwarder *ForwarderImpl) GetTargets() []*net.UDPAddr
  • func (forwarder *ForwarderImpl) ListenerIps() []*net.UDPAddr
  • func (forwarder *ForwarderImpl) MDNSNetworkInterfaces() []*net.Interface
  • func (forwarder *ForwarderImpl) Run() error
  • func (forwarder *ForwarderImpl) SkipOwnIP() bool
• type Handler
  • func NewHandler(forwarder Forwarder) *Handler
  • func (handler *Handler) Run() error
  • func (handler *Handler) Start() error
• type InterfaceCache
  • func (interfaceCache *InterfaceCache) IsInNetwork(networkInterface *net.Interface, address net.IP) bool
• type InterfaceHandler
  • func NewInterfaceHandler(networkInterface *net.Interface) (*InterfaceHandler, error)
  • func NewInterfaceHandlerWithAddress(networkInterface *net.Interface, multicastAddress string) (*InterfaceHandler, error)
  • func (interfaceHandler *InterfaceHandler) Run(channel chan *UDPMessage) error
  • func (interfaceHandler *InterfaceHandler) Send(message []byte) error
  • func (interfaceHandler *InterfaceHandler) Start() error
  • func (interfaceHandler *InterfaceHandler) Stop() error
• type ListenerHandler
  • func NewListenerHandler(addr *net.UDPAddr) (*ListenerHandler, error)
  • func (handler *ListenerHandler) Close() error
  • func (handler *ListenerHandler) Run(channel chan *RemoteUDPMessage) error
  • func (handler *ListenerHandler) Start() error
• type RemoteUDPMessage
• type TargetHandler
  • func NewTargetHandler(target *net.UDPAddr) *TargetHandler
  • func (handler *TargetHandler) Send(data []byte) error
• type TimedInterfaceCache
  • func NewTimedInterfaceCache() *TimedInterfaceCache
  • func NewTimedInterfaceCacheExpiresAt(expires time.Time) *TimedInterfaceCache
  • func (interfaceCache *TimedInterfaceCache) Expired() bool
  • func (interfaceCache *TimedInterfaceCache) IsInNetwork(networkInterface *net.Interface, address net.IP) bool
• type UDPMessage

Types

type Forwarder

type Forwarder interface {
	MDNSNetworkInterfaces() []*net.Interface
	ListenerIps() []*net.UDPAddr
	GetTargets() []*net.UDPAddr
	SkipOwnIP() bool
	Run() error
}

Forwarder is the main interface which is used to store information for the mdns forwarder to handle network multicasting.

func New

func New(interfaces []*net.Interface, listenerIps []*net.UDPAddr, targets []*net.UDPAddr, skipOwnIP bool) Forwarder

type ForwarderImpl

type ForwarderImpl struct {
	// contains filtered or unexported fields
}

func (*ForwarderImpl) GetTargets

func (forwarder *ForwarderImpl) GetTargets() []*net.UDPAddr

func (*ForwarderImpl) ListenerIps

func (forwarder *ForwarderImpl) ListenerIps() []*net.UDPAddr

func (*ForwarderImpl) MDNSNetworkInterfaces

func (forwarder *ForwarderImpl) MDNSNetworkInterfaces() []*net.Interface

func (*ForwarderImpl) Run

func (forwarder *ForwarderImpl) Run() error

func (*ForwarderImpl) SkipOwnIP

func (forwarder *ForwarderImpl) SkipOwnIP() bool

type Handler

type Handler struct {
	// contains filtered or unexported fields
}

Handler includes the logic for forwarding and handling mdns messages.

func NewHandler

func NewHandler(forwarder Forwarder) *Handler

func (*Handler) Run

func (handler *Handler) Run() error

func (*Handler) Start

func (handler *Handler) Start() error

type InterfaceCache

type InterfaceCache struct {
	// contains filtered or unexported fields
}

func (*InterfaceCache) IsInNetwork

func (interfaceCache *InterfaceCache) IsInNetwork(networkInterface *net.Interface, address net.IP) bool

type InterfaceHandler

type InterfaceHandler struct {
	// contains filtered or unexported fields
}

func NewInterfaceHandler

func NewInterfaceHandler(networkInterface *net.Interface) (*InterfaceHandler, error)

func NewInterfaceHandlerWithAddress

func NewInterfaceHandlerWithAddress(networkInterface *net.Interface, multicastAddress string) (*InterfaceHandler, error)

func (*InterfaceHandler) Run

func (interfaceHandler *InterfaceHandler) Run(channel chan *UDPMessage) error

func (*InterfaceHandler) Send

func (interfaceHandler *InterfaceHandler) Send(message []byte) error

func (*InterfaceHandler) Start

func (interfaceHandler *InterfaceHandler) Start() error

func (*InterfaceHandler) Stop

func (interfaceHandler *InterfaceHandler) Stop() error

type ListenerHandler

type ListenerHandler struct {
	// contains filtered or unexported fields
}

func NewListenerHandler

func NewListenerHandler(addr *net.UDPAddr) (*ListenerHandler, error)

func (*ListenerHandler) Close

func (handler *ListenerHandler) Close() error

func (*ListenerHandler) Run

func (handler *ListenerHandler) Run(channel chan *RemoteUDPMessage) error

func (*ListenerHandler) Start

func (handler *ListenerHandler) Start() error

type RemoteUDPMessage

type RemoteUDPMessage struct {
	Address  *net.UDPAddr
	NumBytes int
	Data     []byte
}

RemoteUDPMessage represents a data being sent to a unicast listener for forwarding the message to all local networks.

type TargetHandler

type TargetHandler struct {
	// contains filtered or unexported fields
}

func NewTargetHandler

func NewTargetHandler(target *net.UDPAddr) *TargetHandler

func (*TargetHandler) Send

func (handler *TargetHandler) Send(data []byte) error

type TimedInterfaceCache

type TimedInterfaceCache struct {
	// contains filtered or unexported fields
}

func NewTimedInterfaceCache

func NewTimedInterfaceCache() *TimedInterfaceCache

func NewTimedInterfaceCacheExpiresAt

func NewTimedInterfaceCacheExpiresAt(expires time.Time) *TimedInterfaceCache

func (*TimedInterfaceCache) Expired

func (interfaceCache *TimedInterfaceCache) Expired() bool

func (*TimedInterfaceCache) IsInNetwork

func (interfaceCache *TimedInterfaceCache) IsInNetwork(networkInterface *net.Interface, address net.IP) bool

type UDPMessage

type UDPMessage struct {
	Interface *net.Interface
	Address   *net.UDPAddr
	NumBytes  int
	Data      []byte
}

UDPMessage is a message structure which represents one sent datagram from a listened message.