How to find server real IP

How do I find the public IP address of the machine or server my program is running on?

Like when the program is executed it detect the public of the server and print for e.g.running at 123.45.67.89

The short answer is that there's no method guaranteed to return your "public" ip address.

The first question is, what is your public ip address? The address of your machine, as seen by the system to which you are connecting, may vary depending on how your local Internet service is configured and on the service to which you're connecting:

• As I mentioned in a comment, in a typical home environment your machine doesn't have a public ip address. The public address is hosted by your router.

• If you're accessing a service through a proxy or vpn, your machine's address may be entirely different from when you're directly connecting to a service.

• On a system with multiple interfaces, the origin address selected may depend upon the address to which you are connecting: different addresses may have different routes.

You can try using a service like http://icanhazip.com/ to try to determine your public ip. This will be correct in many but not all situations.

public IP address is a vague notion, in practice, it might or might not be a static address. What do you know about that ? It is just a endpoint valid for a certain amount of time, which depends on many factors like which interface was used to issue the query.

We can use the mainline bittorrent dht to give us some indications.

The Go language provides the cool dht package written by anacrolix.

When querying nodes with a find_peers verb we receive a packet containing the remote ip address the peer has associated with our query. This is described in bep10.

If an UDP connection is not a good option, you might opt for a query to bittorent trackers as described in bep24

Consider that peers might be malicious, thus the more results, the better.

Below program outputs the list of external network addresses associated with the computer initiating the query from the POV of the cohort of nodes queried.

Addresses are scored by the numbers of response.

read also https://www.bittorrent.org/beps/bep_0005.html

found 9 bootstrap peers
found 6 peers
4    [2001:861:51c5:xxx:40d1:8061:1fe0:xxx]:9090
2    81.96.42.191:9090

• 4 peers told us that we were using [2001:861:51c5:xxx:40d1:8061:1fe0:xxx]:9090, we can infer this is ipv6.
• 2 of them told we were using 81.96.42.191:9090, the ipv4 interface.

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net"
	"os"
	"sort"
	"sync"
	"time"

	"github.com/anacrolix/dht"
	"github.com/anacrolix/dht/krpc"
	"github.com/anacrolix/torrent/bencode"
)

var maxTimeout = time.Second * 5

func main() {
	b, _ := ioutil.ReadFile("db.json")
	var rawAddrs []string
	json.Unmarshal(b, &rawAddrs)
	defer func() {
		if len(rawAddrs) < 1 {
			return
		}
		if len(rawAddrs) > 30 {
			rawAddrs = rawAddrs[:30]
		}
		buf, err := json.Marshal(rawAddrs)
		if err != nil {
			panic(err)
		}
		err = ioutil.WriteFile("db.json", buf, os.ModePerm)
		if err != nil {
			panic(err)
		}
		fmt.Fprintf(os.Stderr, "%v peers recorded\n", len(rawAddrs))
	}()
	bootstrap, err := parseAddrs(rawAddrs)
	if err != nil {
		bootstrap, err = globalBootstrapAddrs()
		if err != nil {
			panic(err)
		}
	}

	findPeers := []byte(`d1:ad2:id20:abcdefghij01234567899:info_hash20:mnopqrstuvwxyz123456e1:q9:get_peers1:t2:aa1:y1:qe`)

	local, err := net.ResolveUDPAddr("udp", "0.0.0.0:9090")
	if err != nil {
		panic(err)
	}
	ln, err := net.ListenUDP("udp", local)
	if err != nil {
		panic(err)
	}

	addrscores := map[string]int{}

	var drain drain
	defer drain.Wait()
	fmt.Fprintf(os.Stderr, "found %v bootstrap peers\n", len(bootstrap))
	res, errs := readResponses(ln, len(bootstrap), sendQuery(ln, bootstrap, findPeers))
	drain.Errors(errs)

	peers := []net.Addr{}
	for d := range res {
		if isValidAddr(d.IP.UDP()) {
			addrscores[d.IP.String()]++
			d.R.ForAllNodes(func(arg1 krpc.NodeInfo) {
				peers = append(peers, arg1.Addr.UDP())
			})
		}
	}

	if len(peers) > 0 {
		fmt.Fprintf(os.Stderr, "found %v peers\n", len(peers))
		res, errs = readResponses(ln, len(peers), sendQuery(ln, peers, findPeers))
		drain.Errors(errs)
		for d := range res {
			if isValidAddr(d.IP.UDP()) {
				addrscores[d.IP.String()]++
			}
		}
	}

	for _, peer := range peers {
		if isValidAddr(peer) {
			rawAddrs = append(rawAddrs, peer.String())
		}
	}

	addrs := make([]string, 0, len(addrscores))
	for addr := range addrscores {
		addrs = append(addrs, addr)
	}
	sort.Slice(addrs, func(i int, j int) bool {
		return addrscores[addrs[i]] > addrscores[addrs[j]]
	})

	for _, addr := range addrs {
		fmt.Printf("%-4v %v\n", addrscores[addr], addr)
	}
}

type drain struct{ sync.WaitGroup }

func (d *drain) Errors(errs <-chan error) {
	d.Add(1)
	go func() {
		defer d.Done()
		for err := range errs {
			fmt.Fprintln(os.Stderr, err)
		}
	}()
}

func parseAddrs(rawAddrs []string) (addrs []net.Addr, err error) {
	for _, s := range rawAddrs {
		host, port, err := net.SplitHostPort(s)
		if err != nil {
			panic(err)
		}
		ua, err := net.ResolveUDPAddr("udp", net.JoinHostPort(host, port))
		if err != nil {
			log.Printf("error resolving %q: %v", host, err)
			continue
		}
		addrs = append(addrs, ua)
	}
	if len(addrs) == 0 {
		err = errors.New("nothing resolved")
	}
	return
}

func globalBootstrapAddrs() (addrs []net.Addr, err error) {
	bootstrap, err := dht.GlobalBootstrapAddrs("udp")
	if err != nil {
		return nil, err
	}
	for _, b := range bootstrap {
		addrs = append(addrs, b.Raw())
	}
	return
}

func isValidAddr(addr net.Addr) bool { // so weird guys.
	return addr.String() != "<nil>" && addr.String() != ":0"
}

func sendQuery(ln *net.UDPConn, peers []net.Addr, query []byte) chan error {
	errs := make(chan error)

	for _, addr := range peers {
		go func(addr net.Addr) {
			_, err := ln.WriteTo(query, addr)
			if err != nil {
				errs <- addressedError{Op: "send", error: err, Addr: addr}
			}
		}(addr)
	}

	return errs
}

func readResponses(ln *net.UDPConn, count int, errs chan error) (<-chan krpc.Msg, <-chan error) {

	data := make(chan krpc.Msg)
	var wg sync.WaitGroup
	for i := 0; i < count; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			buf := make([]byte, 1000)
			ln.SetReadDeadline(time.Now().Add(maxTimeout))
			n, remoteAddr, err := ln.ReadFromUDP(buf)
			if err != nil {
				errs <- addressedError{Op: "rcv", error: err, Addr: remoteAddr}
				return
			}
			var m krpc.Msg
			err = bencode.Unmarshal(buf[:n], &m)
			if err != nil {
				errs <- addressedError{Op: "rcv", error: err, Addr: remoteAddr}
				return
			}
			data <- m
		}()
	}
	go func() {
		wg.Wait()
		close(errs)
		close(data)
	}()

	return data, errs
}

type addressedError struct {
	error
	Op   string
	Addr net.Addr
}

func (a addressedError) Error() string {
	if !isValidAddr(a.Addr) {
		return fmt.Sprintf("%-5v %v", a.Op, a.error.Error())
	}
	return fmt.Sprintf("%-5v %v: %v", a.Op, a.Addr.String(), a.error.Error())
}