Remove BIRDv1 support

2020-10-30 23:10:03 +08:00 · 2020-10-30 23:10:03 +08:00 · 3bcfc3d36c
commit 3bcfc3d36c
parent 79431effb2
12 changed files with 141 additions and 229 deletions
--- a/README.md
+++ b/README.md
@ -3,6 +3,8 @@ Bird-lg-go

 An alternative implementation for [bird-lg](https://github.com/sileht/bird-lg) written in Go. Both frontend and backend (proxy) are implemented, and can work with either the original Python implementation or the Go implementation.

+> The code on master branch no longer support BIRDv1. Branch "bird1" is the last version that supports BIRDv1.
+
 Frontend
 --------

@ -18,11 +20,16 @@ Features implemented:

 Usage: all configuration is done via commandline parameters or environment variables, no config file.

- --servers / BIRDLG_SERVERS: server name prefixes, separated by comma
- --domain / BIRDLG_DOMAIN: server name domain suffixes
- --listen / BIRDLG_LISTEN: address bird-lg is listening on (default ":5000")
- --proxy-port / BIRDLG_PROXY_PORT: port bird-lgproxy is running on (default 8000)
- --whois / BIRDLG_WHOIS: whois server for queries (default "whois.verisign-grs.com")
+| Parameter | Environment Variable | Description |
+| --------- | -------------------- | ----------- |
+| --servers | BIRDLG_SERVERS | server name prefixes, separated by comma |
+| --domain | BIRDLG_DOMAIN | server name domain suffixes |
+| --listen | BIRDLG_LISTEN | address bird-lg is listening on (default ":5000") |
+| --proxy-port | BIRDLG_PROXY_PORT | port bird-lgproxy is running on (default 8000) |
+| --whois | BIRDLG_WHOIS | whois server for queries (default "whois.verisign-grs.com") |
+| --dns-interface | BIRDLG_DNS_INTERFACE | dns zone to query ASN information (default "asn.cymru.com") |
+| --title-brand | BIRDLG_TITLE_BRAND | prefix of page titles in browser tabs (default "Bird-lg Go") |
+| --navbar-brand | BIRDLG_NAVBAR_BRAND | brand to show in the navigation bar (default "Bird-lg Go") |

 Example: the following command starts the frontend with 2 BIRD nodes, with domain name "gigsgigscloud.dn42.lantian.pub" and "hostdare.dn42.lantian.pub", and proxies are running on port 8000 on both nodes.

@ -50,18 +57,18 @@ The proxy directory contains the code for the "proxy" for bird commands and trac

 Features implemented:

- Sending queries to BIRD and BIRD6
-  - If you are using BIRDv2, simply point both `--bird` and `--bird6` to the only socket file of BIRDv2
+- Sending queries to BIRD
 - Sending "restrict" command to BIRD to prevent unauthorized changes
 - Executing traceroute command on Linux, FreeBSD and OpenBSD
 - Source IP restriction

 Usage: all configuration is done via commandline parameters or environment variables, no config file.

- --allowed / ALLOWED_IPS: IPs allowed to access this proxy, separated by commas. Don't set to allow all IPs. (default "")
- --bird / BIRD_SOCKET: socket file for bird, set either in parameter or environment variable BIRD_SOCKET (default "/var/run/bird/bird.ctl")
- --bird6 / BIRD6_SOCKET: socket file for bird6, set either in parameter or environment variable BIRD6_SOCKET (default "/var/run/bird/bird6.ctl")
- --listen / BIRDLG_LISTEN: listen address, set either in parameter or environment variable BIRDLG_LISTEN (default ":8000")
+| Parameter | Environment Variable | Description |
+| --------- | -------------------- | ----------- |
+| --allowed | ALLOWED_IPS | IPs allowed to access this proxy, separated by commas. Don't set to allow all IPs. (default "") |
+| --bird | BIRD_SOCKET | socket file for bird, set either in parameter or environment variable BIRD_SOCKET (default "/var/run/bird/bird.ctl") |
+| --listen | BIRDLG_LISTEN | listen address, set either in parameter or environment variable BIRDLG_LISTEN (default ":8000") |

 Example: start proxy with default configuration, should work "out of the box" on Debian 9 with BIRDv1:

@ -69,7 +76,7 @@ Example: start proxy with default configuration, should work "out of the box" on

 Example: start proxy with custom bird socket location:

-    ./proxy --bird /run/bird.ctl --bird6 /run/bird6.ctl
+    ./proxy --bird /run/bird.ctl

 Example: the following docker-compose.yml entry does the same as above, but by starting a Docker container:

@ -79,7 +86,6 @@ Example: the following docker-compose.yml entry does the same as above, but by s
      restart: always
      volumes:
        - "/run/bird.ctl:/var/run/bird/bird.ctl"
-        - "/run/bird6.ctl:/var/run/bird/bird6.ctl"
      ports:
        - "192.168.0.1:8000:8000"

@ -88,6 +94,7 @@ You can use source IP restriction to increase security. You should also bind the
 Credits
 -------

+- Everyone who contributed to this project (see Contributors section on the right)
 - Mehdi Abaakouk for creating [the original bird-lg project](https://github.com/sileht/bird-lg)
 - [Bootstrap](https://getbootstrap.com/) as web UI framework

@ -95,4 +102,3 @@ License
 -------

 GPL 3.0
-
--- a/frontend/go.mod
+++ b/frontend/go.mod
@ -0,0 +1,5 @@
+module github.com/xddxdd/bird-lg-go/frontend
+
+go 1.15
+
+require github.com/gorilla/handlers v1.5.1
--- a/frontend/go.sum
+++ b/frontend/go.sum
@ -0,0 +1,4 @@
+github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ=
+github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4=
+github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q=
--- a/frontend/render.go
+++ b/frontend/render.go
@ -9,20 +9,20 @@ import (

 func renderTemplate(w http.ResponseWriter, r *http.Request, title string, content string) {
 	path := r.URL.Path[1:]
-	split := strings.SplitN(path, "/", 4)
+	split := strings.SplitN(path, "/", 3)

 	isWhois := strings.ToLower(split[0]) == "whois"
 	whoisTarget := strings.Join(split[1:], "/")

 	// Use a default URL if the request URL is too short
-	// The URL is for return to IPv4 summary page
-	if len(split) < 3 {
-		path = "ipv4/summary/" + strings.Join(setting.servers, "+") + "/"
-	} else if len(split) == 3 {
+	// The URL is for return to summary page
+	if len(split) < 2 {
+		path = "summary/" + strings.Join(setting.servers, "+") + "/"
+	} else if len(split) == 2 {
 		path += "/"
 	}

-	split = strings.SplitN(path, "/", 4)
+	split = strings.SplitN(path, "/", 3)

 	var args tmplArguments
 	args.Options = map[string]string{
@ -40,24 +40,20 @@ func renderTemplate(w http.ResponseWriter, r *http.Request, title string, conten
 		"traceroute":         "traceroute ...",
 	}
 	args.Servers = setting.servers
-	args.AllServersLinkActive = strings.ToLower(split[2]) == strings.ToLower(strings.Join(setting.servers, "+"))
+	args.AllServersLinkActive = strings.ToLower(split[1]) == strings.ToLower(strings.Join(setting.servers, "+"))
 	args.AllServersURL = strings.Join(setting.servers, "+")
 	args.IsWhois = isWhois
 	args.WhoisTarget = whoisTarget

-	args.URLProto = strings.ToLower(split[0])
-	args.URLOption = strings.ToLower(split[1])
-	args.URLServer = strings.ToLower(split[2])
-	args.URLCommand = split[3]
+	args.URLOption = strings.ToLower(split[0])
+	args.URLServer = strings.ToLower(split[1])
+	args.URLCommand = split[2]

 	args.Title = setting.titleBrand + title
 	args.Brand = setting.navBarBrand
 	args.Content = content

-	err := tmpl.Execute(w, args)
-	if err != nil {
-		panic(err)
-	}
+	tmpl.Execute(w, args)
 }

 // Write the given text to http response, and add whois links for
@ -87,7 +83,7 @@ type summaryTableArguments struct {
 }

 // Output a table for the summary page
-func summaryTable(isIPv6 bool, data string, serverName string) string {
+func summaryTable(data string, serverName string) string {
 	var result string

 	// Sort the table, excluding title row
@ -152,11 +148,7 @@ func summaryTable(isIPv6 bool, data string, serverName string) string {
 				"passive": "table-info",
 			})[row[3]] + `">`
 			// Add link to detail for first column
-			if isIPv6 {
-				result += `<td><a href="/ipv6/detail/` + serverName + `/` + row[0] + `">` + row[0] + `</a></td>`
-			} else {
-				result += `<td><a href="/ipv4/detail/` + serverName + `/` + row[0] + `">` + row[0] + `</a></td>`
-			}
+			result += `<td><a href="/detail/` + serverName + `/` + row[0] + `">` + row[0] + `</a></td>`
 			// Draw the other cells
 			for i := 1; i < 6; i++ {
 				result += "<td>" + row[i] + "</td>"
--- a/frontend/telegram_bot.go
+++ b/frontend/telegram_bot.go
@ -87,17 +87,13 @@ func webHandlerTelegramBot(w http.ResponseWriter, r *http.Request) {
 	commandResult := ""

 	// - traceroute
-	if telegramIsCommand(request.Message.Text, "trace") || telegramIsCommand(request.Message.Text, "trace4") {
+	if telegramIsCommand(request.Message.Text, "trace") {
 		commandResult = telegramBatchRequestFormat(servers, "traceroute", target, telegramDefaultPostProcess)
-	} else if telegramIsCommand(request.Message.Text, "trace6") {
-		commandResult = telegramBatchRequestFormat(servers, "traceroute6", target, telegramDefaultPostProcess)

-	} else if telegramIsCommand(request.Message.Text, "route") || telegramIsCommand(request.Message.Text, "route4") {
+	} else if telegramIsCommand(request.Message.Text, "route") {
 		commandResult = telegramBatchRequestFormat(servers, "bird", "show route for "+target+" primary", telegramDefaultPostProcess)
-	} else if telegramIsCommand(request.Message.Text, "route6") {
-		commandResult = telegramBatchRequestFormat(servers, "bird6", "show route for "+target+" primary", telegramDefaultPostProcess)

-	} else if telegramIsCommand(request.Message.Text, "path") || telegramIsCommand(request.Message.Text, "path4") {
+	} else if telegramIsCommand(request.Message.Text, "path") {
 		commandResult = telegramBatchRequestFormat(servers, "bird", "show route for "+target+" all primary", func(result string) string {
 			for _, s := range strings.Split(result, "\n") {
 				if strings.Contains(s, "BGP.as_path: ") {
@ -106,15 +102,6 @@ func webHandlerTelegramBot(w http.ResponseWriter, r *http.Request) {
 			}
 			return ""
 		})
-	} else if telegramIsCommand(request.Message.Text, "path6") {
-		commandResult = telegramBatchRequestFormat(servers, "bird6", "show route for "+target+" all primary", func(result string) string {
-			for _, s := range strings.Split(result, "\n") {
-				if strings.Contains(s, "BGP.as_path: ") {
-					return strings.TrimSpace(strings.Split(s, ":")[1])
-				}
-			}
-			return ""
-		})

 	} else if telegramIsCommand(request.Message.Text, "whois") {
 		if setting.netSpecificMode == "dn42" {
@ -137,9 +124,9 @@ func webHandlerTelegramBot(w http.ResponseWriter, r *http.Request) {

 	} else if telegramIsCommand(request.Message.Text, "help") {
 		commandResult = `
-/[path|path6] <IP>
-/[route|route6] <IP>
-/[trace|trace6] <IP>
+/path <IP>
+/route <IP>
+/trace <IP>
 /whois <Target>
 		`
 	} else {
--- a/frontend/template.go
+++ b/frontend/template.go
@ -17,7 +17,6 @@ type tmplArguments struct {
 	IsWhois     bool
 	WhoisTarget string

-	URLProto   string
 	URLOption  string
 	URLServer  string
 	URLCommand string
@ -49,34 +48,37 @@ var tmpl = template.Must(template.New("tmpl").Parse(`
 	</button>

 	<div class="collapse navbar-collapse" id="navbarSupportedContent">
+		{{ $option := .URLOption }}
+		{{ $server := .URLServer }}
+		{{ $target := .URLCommand }}
+		{{ if .IsWhois }}
+			{{ $option = "summary" }}
+			{{ $server = .AllServersURL }}
+			{{ $target = "" }}
+		{{ end }}
 		<ul class="navbar-nav mr-auto">
-			<li class="nav-item"><a class="nav-link{{ if eq "ipv4" .URLProto }} active{{ end }}" href="/ipv4/{{ .URLOption }}/{{ .URLServer }}/{{ .URLCommand }}"> IPv4 </a></li>
-			<li class="nav-item"><a class="nav-link{{ if eq "ipv6" .URLProto }} active{{ end }}" href="/ipv6/{{ .URLOption }}/{{ .URLServer }}/{{ .URLCommand }}"> IPv6 </a></li>
-			<span class="navbar-text">|</span>
 			<li class="nav-item">
-				<a class="nav-link{{ if .AllServersLinkActive }} active{{ end }}" href="/{{ .URLProto }}/{{ .URLOption }}/{{ .AllServersURL }}/{{ .URLCommand }}"> All Servers </a>
+				<a class="nav-link{{ if .AllServersLinkActive }} active{{ end }}"
+					href="/{{ $option }}/{{ .AllServersURL }}/{{ $target }}"> All Servers </a>
 			</li>
 			{{ range $k, $v := .Servers }}
 			<li class="nav-item">
-				<a class="nav-link{{ if eq $.URLServer $v }} active{{ end }}" href="/{{ $.URLProto }}/{{ $.URLOption }}/{{ $v }}/{{ $.URLCommand }}">{{ $v }}</a>
+				<a class="nav-link{{ if eq $server $v }} active{{ end }}"
+					href="/{{ $option }}/{{ $v }}/{{ $target }}">{{ $v }}</a>
 			</li>
 			{{ end }}
 		</ul>
-		{{ $option := .URLOption }}
-		{{ $target := .URLCommand }}
 		{{ if .IsWhois }}
-			{{ $option = "whois" }}
 			{{ $target = .WhoisTarget }}
 		{{ end }}
 		<form class="form-inline" action="/redir" method="GET">
 			<div class="input-group">
 				<select name="action" class="form-control">
 					{{ range $k, $v := .Options }}
-					<option value="{{ $k }}"{{ if eq $k $option }} selected{{end}}>{{ $v }}</option>
+					<option value="{{ $k }}"{{ if eq $k $.URLOption }} selected{{end}}>{{ $v }}</option>
 					{{ end }}
 				</select>
-				<input name="proto" class="d-none" value="{{ .URLProto }}">
-				<input name="server" class="d-none" value="{{ .URLServer }}">
+				<input name="server" class="d-none" value="{{ $server }}">
 				<input name="target" class="form-control" placeholder="Target" aria-label="Target" value="{{ $target }}">
 				<div class="input-group-append">
 					<button class="btn btn-outline-success" type="submit">&raquo;</button>
--- a/frontend/webserver.go
+++ b/frontend/webserver.go
@ -40,8 +40,8 @@ func webBackendCommunicator(endpoint string, command string) func(w http.Respons
 	return func(w http.ResponseWriter, r *http.Request) {
 		split := strings.SplitN(r.URL.Path[1:], "/", 4)
 		var urlCommands string
-		if len(split) >= 4 {
-			urlCommands = split[3]
+		if len(split) >= 3 {
+			urlCommands = split[2]
 		}

 		var backendCommand string
@ -52,14 +52,13 @@ func webBackendCommunicator(endpoint string, command string) func(w http.Respons
 		}
 		backendCommand = strings.TrimSpace(backendCommand)

-		var servers []string = strings.Split(split[2], "+")
+		var servers []string = strings.Split(split[1], "+")
 		var responses []string = batchRequest(servers, endpoint, backendCommand)
 		var result string
 		for i, response := range responses {
 			result += "<h2>" + html.EscapeString(servers[i]) + ": " + html.EscapeString(backendCommand) + "</h2>"
-			if (endpoint == "bird" || endpoint == "bird6") && backendCommand == "show protocols" && len(response) > 4 && strings.ToLower(response[0:4]) == "name" {
-				var isIPv6 bool = endpoint[len(endpoint)-1] == '6'
-				result += summaryTable(isIPv6, response, servers[i])
+			if (endpoint == "bird") && backendCommand == "show protocols" && len(response) > 4 && strings.ToLower(response[0:4]) == "name" {
+				result += summaryTable(response, servers[i])
 			} else {
 				result += smartFormatter(response)
 			}
@ -85,7 +84,7 @@ func webHandlerBGPMap(endpoint string, command string) func(w http.ResponseWrite

 	return func(w http.ResponseWriter, r *http.Request) {
 		split := strings.Split(r.URL.Path[1:], "/")
-		urlCommands := strings.Join(split[3:], "/")
+		urlCommands := strings.Join(split[2:], "/")

 		var backendCommand string
 		if strings.Contains(backendCommandPrimitive, "%") {
@ -94,7 +93,7 @@ func webHandlerBGPMap(endpoint string, command string) func(w http.ResponseWrite
 			backendCommand = backendCommandPrimitive
 		}

-		var servers []string = strings.Split(split[2], "+")
+		var servers []string = strings.Split(split[1], "+")
 		var responses []string = batchRequest(servers, endpoint, backendCommand)
 		renderTemplate(
 			w, r,
@ -121,41 +120,41 @@ func webHandlerNavbarFormRedirect(w http.ResponseWriter, r *http.Request) {
 	if query.Get("action") == "whois" {
 		http.Redirect(w, r, "/"+query.Get("action")+"/"+query.Get("target"), 302)
 	} else if query.Get("action") == "summary" {
-		http.Redirect(w, r, "/"+query.Get("proto")+"/"+query.Get("action")+"/"+query.Get("server"), 302)
+		http.Redirect(w, r, "/"+query.Get("action")+"/"+query.Get("server")+"/", 302)
 	} else {
-		http.Redirect(w, r, "/"+query.Get("proto")+"/"+query.Get("action")+"/"+query.Get("server")+"/"+query.Get("target"), 302)
+		http.Redirect(w, r, "/"+query.Get("action")+"/"+query.Get("server")+"/"+query.Get("target"), 302)
 	}
 }

+func webHandlerRobotsTxt(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("User-agent: *\nDisallow: /\n"))
+}
+
+func webHandler404(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusNotFound)
+	w.Write([]byte("404 not found\n"))
+}
+
 func webServerStart() {
 	// Start HTTP server
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		http.Redirect(w, r, "/ipv4/summary/"+strings.Join(setting.servers, "+"), 302)
+		http.Redirect(w, r, "/summary/"+strings.Join(setting.servers, "+"), 302)
 	})
-	http.HandleFunc("/ipv4/summary/", webBackendCommunicator("bird", "summary"))
-	http.HandleFunc("/ipv6/summary/", webBackendCommunicator("bird6", "summary"))
-	http.HandleFunc("/ipv4/detail/", webBackendCommunicator("bird", "detail"))
-	http.HandleFunc("/ipv6/detail/", webBackendCommunicator("bird6", "detail"))
-	http.HandleFunc("/ipv4/route/", webBackendCommunicator("bird", "route"))
-	http.HandleFunc("/ipv6/route/", webBackendCommunicator("bird6", "route"))
-	http.HandleFunc("/ipv4/route_all/", webBackendCommunicator("bird", "route_all"))
-	http.HandleFunc("/ipv6/route_all/", webBackendCommunicator("bird6", "route_all"))
-	http.HandleFunc("/ipv4/route_bgpmap/", webHandlerBGPMap("bird", "route_bgpmap"))
-	http.HandleFunc("/ipv6/route_bgpmap/", webHandlerBGPMap("bird6", "route_bgpmap"))
-	http.HandleFunc("/ipv4/route_where/", webBackendCommunicator("bird", "route_where"))
-	http.HandleFunc("/ipv6/route_where/", webBackendCommunicator("bird6", "route_where"))
-	http.HandleFunc("/ipv4/route_where_all/", webBackendCommunicator("bird", "route_where_all"))
-	http.HandleFunc("/ipv6/route_where_all/", webBackendCommunicator("bird6", "route_where_all"))
-	http.HandleFunc("/ipv4/route_where_bgpmap/", webHandlerBGPMap("bird", "route_where_bgpmap"))
-	http.HandleFunc("/ipv6/route_where_bgpmap/", webHandlerBGPMap("bird6", "route_where_bgpmap"))
-	http.HandleFunc("/ipv4/route_generic/", webBackendCommunicator("bird", "route_generic"))
-	http.HandleFunc("/ipv6/route_generic/", webBackendCommunicator("bird6", "route_generic"))
-	http.HandleFunc("/ipv4/generic/", webBackendCommunicator("bird", "generic"))
-	http.HandleFunc("/ipv6/generic/", webBackendCommunicator("bird6", "generic"))
-	http.HandleFunc("/ipv4/traceroute/", webBackendCommunicator("traceroute", "traceroute"))
-	http.HandleFunc("/ipv6/traceroute/", webBackendCommunicator("traceroute6", "traceroute"))
+	http.HandleFunc("/summary/", webBackendCommunicator("bird", "summary"))
+	http.HandleFunc("/detail/", webBackendCommunicator("bird", "detail"))
+	http.HandleFunc("/route/", webBackendCommunicator("bird", "route"))
+	http.HandleFunc("/route_all/", webBackendCommunicator("bird", "route_all"))
+	http.HandleFunc("/route_bgpmap/", webHandlerBGPMap("bird", "route_bgpmap"))
+	http.HandleFunc("/route_where/", webBackendCommunicator("bird", "route_where"))
+	http.HandleFunc("/route_where_all/", webBackendCommunicator("bird", "route_where_all"))
+	http.HandleFunc("/route_where_bgpmap/", webHandlerBGPMap("bird", "route_where_bgpmap"))
+	http.HandleFunc("/route_generic/", webBackendCommunicator("bird", "route_generic"))
+	http.HandleFunc("/generic/", webBackendCommunicator("bird", "generic"))
+	http.HandleFunc("/traceroute/", webBackendCommunicator("traceroute", "traceroute"))
 	http.HandleFunc("/whois/", webHandlerWhois)
 	http.HandleFunc("/redir", webHandlerNavbarFormRedirect)
 	http.HandleFunc("/telegram/", webHandlerTelegramBot)
+	http.HandleFunc("/robots.txt", webHandlerRobotsTxt)
+	http.HandleFunc("/favicon.ico", webHandler404)
 	http.ListenAndServe(setting.listen, handlers.LoggingHandler(os.Stdout, http.DefaultServeMux))
 }
--- a/proxy/bird.go
+++ b/proxy/bird.go
@ -89,25 +89,3 @@ func birdHandler(httpW http.ResponseWriter, httpR *http.Request) {
 		}
 	}
 }
-
-// Handles BIRDv6 queries
-func bird6Handler(httpW http.ResponseWriter, httpR *http.Request) {
-	query := string(httpR.URL.Query().Get("q"))
-	if query == "" {
-		invalidHandler(httpW, httpR)
-	} else {
-		// Initialize BIRDv6 socket
-		bird6, err := net.Dial("unix", setting.bird6Socket)
-		if err != nil {
-			panic(err)
-		}
-		defer bird6.Close()
-
-		birdReadln(bird6, nil)
-		birdWriteln(bird6, "restrict")
-		birdReadln(bird6, nil)
-		birdWriteln(bird6, query)
-		for birdReadln(bird6, httpW) {
-		}
-	}
-}
--- a/proxy/go.mod
+++ b/proxy/go.mod
@ -0,0 +1,5 @@
+module github.com/xddxdd/bird-lg-go/proxy
+
+go 1.15
+
+require github.com/gorilla/handlers v1.5.1
--- a/proxy/go.sum
+++ b/proxy/go.sum
@ -0,0 +1,4 @@
+github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ=
+github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4=
+github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q=
--- a/proxy/main.go
+++ b/proxy/main.go
@ -50,10 +50,9 @@ func accessHandler(next http.Handler) http.Handler {
 }

 type settingType struct {
-	birdSocket  string
-	bird6Socket string
-	listen      string
-	allowedIPs  []string
+	birdSocket string
+	listen     string
+	allowedIPs []string
 }

 var setting settingType
@ -63,7 +62,6 @@ func main() {
 	// Prepare default socket paths, use environment variable if possible
 	var settingDefault = settingType{
 		"/var/run/bird/bird.ctl",
-		"/var/run/bird/bird6.ctl",
 		":8000",
 		[]string{""},
 	}
@ -71,9 +69,6 @@ func main() {
 	if birdSocketEnv := os.Getenv("BIRD_SOCKET"); birdSocketEnv != "" {
 		settingDefault.birdSocket = birdSocketEnv
 	}
-	if bird6SocketEnv := os.Getenv("BIRD6_SOCKET"); bird6SocketEnv != "" {
-		settingDefault.bird6Socket = bird6SocketEnv
-	}
 	if listenEnv := os.Getenv("BIRDLG_LISTEN"); listenEnv != "" {
 		settingDefault.listen = listenEnv
 	}
@ -83,21 +78,17 @@ func main() {

 	// Allow parameters to override environment variables
 	birdParam := flag.String("bird", settingDefault.birdSocket, "socket file for bird, set either in parameter or environment variable BIRD_SOCKET")
-	bird6Param := flag.String("bird6", settingDefault.bird6Socket, "socket file for bird6, set either in parameter or environment variable BIRD6_SOCKET")
 	listenParam := flag.String("listen", settingDefault.listen, "listen address, set either in parameter or environment variable BIRDLG_LISTEN")
 	AllowedIPsParam := flag.String("allowed", strings.Join(settingDefault.allowedIPs, ","), "IPs allowed to access this proxy, separated by commas. Don't set to allow all IPs.")
 	flag.Parse()

 	setting.birdSocket = *birdParam
-	setting.bird6Socket = *bird6Param
 	setting.listen = *listenParam
 	setting.allowedIPs = strings.Split(*AllowedIPsParam, ",")

 	// Start HTTP server
 	http.HandleFunc("/", invalidHandler)
 	http.HandleFunc("/bird", birdHandler)
-	http.HandleFunc("/bird6", bird6Handler)
-	http.HandleFunc("/traceroute", tracerouteIPv4Wrapper)
-	http.HandleFunc("/traceroute6", tracerouteIPv6Wrapper)
+	http.HandleFunc("/traceroute", tracerouteHandler)
 	http.ListenAndServe(*listenParam, handlers.LoggingHandler(os.Stdout, accessHandler(http.DefaultServeMux)))
 }
--- a/proxy/traceroute.go
+++ b/proxy/traceroute.go
@ -4,20 +4,12 @@ import (
 	"fmt"
 	"net/http"
 	"os/exec"
+	"regexp"
 	"runtime"
+	"strconv"
 	"strings"
 )

-// Wrapper of traceroute, IPv4
-func tracerouteIPv4Wrapper(httpW http.ResponseWriter, httpR *http.Request) {
-	tracerouteRealHandler(false, httpW, httpR)
-}
-
-// Wrapper of traceroute, IPv6
-func tracerouteIPv6Wrapper(httpW http.ResponseWriter, httpR *http.Request) {
-	tracerouteRealHandler(true, httpW, httpR)
-}
-
 func tracerouteTryExecute(cmd []string, args [][]string) ([]byte, string) {
 	var output []byte
 	var errString = ""
@ -35,8 +27,7 @@ func tracerouteTryExecute(cmd []string, args [][]string) ([]byte, string) {
 	return nil, errString
 }

-// Real handler of traceroute requests
-func tracerouteRealHandler(useIPv6 bool, httpW http.ResponseWriter, httpR *http.Request) {
+func tracerouteHandler(httpW http.ResponseWriter, httpR *http.Request) {
 	query := string(httpR.URL.Query().Get("q"))
 	query = strings.TrimSpace(query)
 	if query == "" {
@ -44,88 +35,28 @@ func tracerouteRealHandler(useIPv6 bool, httpW http.ResponseWriter, httpR *http.
 	} else {
 		var result []byte
 		var errString string
-		if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
-			if useIPv6 {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute6",
-						"traceroute",
-					},
-					[][]string{
-						{"-q1", "-w1", query},
-						{"-q1", "-w1", query},
-					},
-				)
-			} else {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute",
-						"traceroute6",
-					},
-					[][]string{
-						{"-q1", "-w1", query},
-						{"-q1", "-w1", query},
-					},
-				)
-			}
-		} else if runtime.GOOS == "openbsd" {
-			if useIPv6 {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute6",
-						"traceroute",
-					},
-					[][]string{
-						{"-q1", "-w1", query},
-						{"-q1", "-w1", query},
-					},
-				)
-			} else {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute",
-						"traceroute6",
-					},
-					[][]string{
-						{"-A", "-q1", "-w1", query},
-						{"-A", "-q1", "-w1", query},
-					},
-				)
-			}
+		skippedCounter := 0
+
+		if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" || runtime.GOOS == "openbsd" {
+			result, errString = tracerouteTryExecute(
+				[]string{
+					"traceroute",
+				},
+				[][]string{
+					{"-q1", "-w1", query},
+				},
+			)
 		} else if runtime.GOOS == "linux" {
-			if useIPv6 {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute",
-						"traceroute",
-						"traceroute",
-						"traceroute",
-					},
-					[][]string{
-						{"-6", "-q1", "-N32", "-w1", query},
-						{"-4", "-q1", "-N32", "-w1", query},
-						// For Busybox traceroute which doesn't support simultaneous requests
-						{"-6", "-q1", "-w1", query},
-						{"-4", "-q1", "-w1", query},
-					},
-				)
-			} else {
-				result, errString = tracerouteTryExecute(
-					[]string{
-						"traceroute",
-						"traceroute",
-						"traceroute",
-						"traceroute",
-					},
-					[][]string{
-						{"-4", "-q1", "-N32", "-w1", query},
-						{"-6", "-q1", "-N32", "-w1", query},
-						// For Busybox traceroute which doesn't support simultaneous requests
-						{"-4", "-q1", "-w1", query},
-						{"-6", "-q1", "-w1", query},
-					},
-				)
-			}
+			result, errString = tracerouteTryExecute(
+				[]string{
+					"traceroute",
+					"traceroute",
+				},
+				[][]string{
+					{"-q1", "-N32", "-w1", query},
+					{"-q1", "-w1", query},
+				},
+			)
 		} else {
 			httpW.WriteHeader(http.StatusInternalServerError)
 			httpW.Write([]byte("traceroute not supported on this node.\n"))
@ -133,10 +64,18 @@ func tracerouteRealHandler(useIPv6 bool, httpW http.ResponseWriter, httpR *http.
 		}
 		if errString != "" {
 			httpW.WriteHeader(http.StatusInternalServerError)
-			httpW.Write([]byte("traceroute returned error:\n\n" + errString))
+			httpW.Write([]byte(errString))
 		}
 		if result != nil {
-			httpW.Write(result)
+			errString = string(result)
+			errString = regexp.MustCompile(`\s*(\d*)\s*\*\n`).ReplaceAllStringFunc(errString, func(w string) string {
+				skippedCounter++
+				return ""
+			})
+			httpW.Write([]byte(strings.TrimSpace(errString)))
+			if skippedCounter > 0 {
+				httpW.Write([]byte("\n\n" + strconv.Itoa(skippedCounter) + " hops not responding."))
+			}
 		}
 	}
 }