burble.dn42/bird-lg-go
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Multiple UI and functionality fixes

Browse Source
This commit is contained in:
Lan Tian 2020-03-26 01:05:13 +08:00
parent 5d91c9d6d1
commit 19fd44c28e
No known key found for this signature in database
GPG Key ID: 27F31700E751EC22
6 changed files with 485 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
frontend/lgproxy.go
View File

@ -1,58 +1,61 @@
package main package main
import ( import (
"net/http" "io/ioutil"
"net/url" "net/http"
"io/ioutil" "net/url"
"strconv" "strconv"
) )
type channelData struct { type channelData struct {
id int id int
data string data string
} }
// Send commands to lgproxy instances in parallel, and retrieve their responses // Send commands to lgproxy instances in parallel, and retrieve their responses
func batchRequest(servers []string, endpoint string, command string) []string { func batchRequest(servers []string, endpoint string, command string) []string {
// Channel and array for storing responses // Channel and array for storing responses
var ch chan channelData = make(chan channelData) var ch chan channelData = make(chan channelData)
var response_array []string = make([]string, len(servers)) var responseArray []string = make([]string, len(servers))
for i, server := range servers { for i, server := range servers {
// Check if the server is in the valid server list passed at startup // Check if the server is in the valid server list passed at startup
var isValidServer bool = false var isValidServer bool = false
for _, validServer := range settingServers { for _, validServer := range settingServers {
if validServer == server { if validServer == server {
isValidServer = true isValidServer = true
break break
} }
} }
if !isValidServer { if !isValidServer {
// If the server is not valid, create a dummy goroutine to return a failure // If the server is not valid, create a dummy goroutine to return a failure
go func (i int) { go func(i int) {
ch <- channelData{i, "request failed: invalid server\n"} ch <- channelData{i, "request failed: invalid server\n"}
} (i) }(i)
} else { } else {
// Compose URL and send the request // Compose URL and send the request
url := "http://" + server + "." + settingServersDomain + ":" + strconv.Itoa(settingServersPort) + "/" + url.PathEscape(endpoint) + "?q=" + url.QueryEscape(command) url := "http://" + server + "." + settingServersDomain + ":" + strconv.Itoa(settingServersPort) + "/" + url.PathEscape(endpoint) + "?q=" + url.QueryEscape(command)
go func (url string, i int){ go func(url string, i int) {
response, err := http.Get(url) response, err := http.Get(url)
if err != nil { if err != nil {
ch <- channelData{i, "request failed: " + err.Error() + "\n"} ch <- channelData{i, "request failed: " + err.Error() + "\n"}
return return
} }
text, _ := ioutil.ReadAll(response.Body) text, _ := ioutil.ReadAll(response.Body)
ch <- channelData{i, string(text)} if len(text) == 0 {
} (url, i) text = []byte("node returned empty response, please refresh to try again.")
} }
} ch <- channelData{i, string(text)}
}(url, i)
}
}
// Sort the responses by their ids, to return data in order // Sort the responses by their ids, to return data in order
for range servers { for range servers {
var output channelData = <-ch var output channelData = <-ch
response_array[output.id] = output.data responseArray[output.id] = output.data
} }
return response_array return responseArray
} }

402
frontend/template.go
View File

@ -1,144 +1,106 @@
package main package main
import ( import (
"net" "net"
"net/http" "net/http"
"strings" "strconv"
"strconv" "strings"
) )
// Helper to check if the IP is valid // Helper to check if the IP is valid
func isIP(s string) bool { func isIP(s string) bool {
return nil != net.ParseIP(s) return nil != net.ParseIP(s)
} }
// Helper to check if the number is valid // Helper to check if the number is valid
func isNumber(s string) bool { func isNumber(s string) bool {
_, err := strconv.Atoi(s) _, err := strconv.Atoi(s)
return nil == err return nil == err
} }
// Print HTML header to the given http response // Print HTML header to the given http response
func templateHeader(w http.ResponseWriter, r *http.Request, title string) { func templateHeader(w http.ResponseWriter, r *http.Request, title string) {
path := r.URL.Path path := r.URL.Path[1:]
split := strings.Split(r.URL.Path, "/") split := strings.Split(path, "/")
// Mark if the URL is for a whois query // Mark if the URL is for a whois query
var isWhois bool = false var isWhois bool = split[0] == "whois"
if len(split) >= 2 && split[1] == "whois" { var whoisTarget string = strings.Join(split[1:], "/")
isWhois = true
}
// Use a default URL if the request URL is too short // Use a default URL if the request URL is too short
// The URL is for return to IPv4 summary page // The URL is for return to IPv4 summary page
if len(split) < 4 { if len(split) < 3 {
path = "/ipv4/summary/" + strings.Join(settingServers[:], "+") + "/" path = "ipv4/summary/" + strings.Join(settingServers[:], "+") + "/"
} else if len(split) == 4 { } else if len(split) == 3 {
path += "/" path += "/"
} }
// Compose URLs for link in navbar split = strings.Split(path, "/")
split = strings.Split(path, "/")
split[1] = "ipv4"
ipv4_url := strings.Join(split, "/")
split = strings.Split(path, "/") // Compose URLs for link in navbar
split[1] = "ipv6" ipv4URL := "/" + strings.Join([]string{"ipv4", split[1], split[2], strings.Join(split[3:], "/")}, "/")
ipv6_url := strings.Join(split, "/") ipv6URL := "/" + strings.Join([]string{"ipv6", split[1], split[2], strings.Join(split[3:], "/")}, "/")
allURL := "/" + strings.Join([]string{split[0], split[1], strings.Join(settingServers[:], "+"), strings.Join(split[3:], "/")}, "/")
split = strings.Split(path, "/") // Check if the "All Server" link should be marked as active
split[3] = strings.Join(settingServers[:], "+") var serverAllActive bool = strings.ToLower(split[2]) == strings.ToLower(strings.Join(settingServers[:], "+"))
all_url := strings.Join(split, "/")
// Check if the "All Server" link should be marked as active // Print the IPv4, IPv6, All Servers link in navbar
split = strings.Split(path, "/") var serverNavigation string = `
var serverAllActive string <li class="nav-item"><a class="nav-link" href="` + ipv4URL + `"` + (map[bool]string{true: " active"})[strings.ToLower(split[0]) == "ipv4"] + `> IPv4 </a></li>
if split[3] == strings.Join(settingServers[:], "+") { <li class="nav-item"><a class="nav-link" href="` + ipv6URL + `"` + (map[bool]string{true: " active"})[strings.ToLower(split[0]) == "ipv6"] + `> IPv6 </a></li>
serverAllActive = " active"
}
// Print the IPv4, IPv6, All Servers link in navbar
var serverNavigation string = `
<li class="nav-item">
<a class="nav-link" href="` + ipv4_url + `"> IPv4 </a>
</li>
<li class="nav-item">
<a class="nav-link" href="` + ipv6_url + `"> IPv6 </a>
</li>
<span class="navbar-text">|</span> <span class="navbar-text">|</span>
<li class="nav-item"> <li class="nav-item">
<a class="nav-link` + serverAllActive + `" href="` + all_url + `"> All Servers </a> <a class="nav-link` + (map[bool]string{true: " active"})[serverAllActive] + `" href="` + allURL + `"> All Servers </a>
</li> </li>`
`
// Add a link for each of the servers // Add a link for each of the servers
for _, server := range settingServers { for _, server := range settingServers {
split = strings.Split(path, "/") var serverActive string
var serverActive string if split[2] == server {
if split[3] == server { serverActive = " active"
serverActive = " active" }
} serverURL := "/" + strings.Join([]string{split[0], split[1], server, strings.Join(split[3:], "/")}, "/")
split[3] = server
server_url := strings.Join(split, "/")
serverNavigation += ` serverNavigation += `
<li class="nav-item"> <li class="nav-item">
<a class="nav-link` + serverActive + `" href="` + server_url + `">` + server + `</a> <a class="nav-link` + serverActive + `" href="` + serverURL + `">` + server + `</a>
</li> </li>`
` }
}
// Add the options in navbar form, and check if they are active // Add the options in navbar form, and check if they are active
var options string var optionKeys = []string{"summary", "detail", "route", "route_all", "route_where", "route_where_all", "whois", "traceroute"}
split = strings.Split(path, "/") var optionDisplays = []string{
if split[2] == "summary" { "show protocol",
options += `<option value="summary" selected>show protocol</option>` "show protocol all",
} else { "show route for ...",
options += `<option value="summary">show protocol</option>` "show route for ... all",
} "show route where net ~ [ ... ]",
if split[2] == "route" { "show route where net ~ [ ... ] all",
options += `<option value="route" selected>show route for ...</option>` "whois ...",
} else { "traceroute ...",
options += `<option value="route">show route for ...</option>` }
}
if split[2] == "route_all" {
options += `<option value="route_all" selected>show route for ... all</option>`
} else {
options += `<option value="route_all">show route for ... all</option>`
}
if split[2] == "route_where" {
options += `<option value="route_where" selected>show route where net ~ [ ... ]</option>`
} else {
options += `<option value="route_where">show route where net ~ [ ... ]</option>`
}
if split[2] == "route_where_all" {
options += `<option value="route_where_all" selected>show route where net ~ [ ... ] all</option>`
} else {
options += `<option value="route_where_all">show route where net ~ [ ... ] all</option>`
}
if isWhois {
options += `<option value="whois" selected>whois ...</option>`
} else {
options += `<option value="whois">whois ...</option>`
}
if split[2] == "traceroute" {
options += `<option value="traceroute" selected>traceroute ...</option>`
} else {
options += `<option value="traceroute">traceroute ...</option>`
}
var target string var options string
if isWhois { for optionKeyID, optionKey := range optionKeys {
// This is a whois request, use original path URL instead of the modified one options += "<option value=\"" + optionKey + "\""
// and extract the target if (optionKey == "whois" && isWhois) || optionKey == split[1] {
whoisSplit := strings.Split(r.URL.Path, "/") options += " selected"
target = strings.Join(whoisSplit[2:], "/") }
} else if len(split) >= 5 { options += ">" + optionDisplays[optionKeyID] + "</option>"
// This is a normal request, just extract the target }
target = strings.Join(split[4:], "/")
}
w.Write([]byte(` var target string
if isWhois {
// This is a whois request, use original path URL instead of the modified one
// and extract the target
target = whoisTarget
} else if len(split) >= 4 {
// This is a normal request, just extract the target
target = strings.Join(split[3:], "/")
}
w.Write([]byte(`
<!DOCTYPE html> <!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN" lang="zh-CN" class="no-js"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN" lang="zh-CN" class="no-js">
<head> <head>
@ -162,8 +124,8 @@ func templateHeader(w http.ResponseWriter, r *http.Request, title string) {
<form class="form-inline" action="/redir" method="GET"> <form class="form-inline" action="/redir" method="GET">
<div class="input-group"> <div class="input-group">
<select name="action" class="form-control">` + options + `</select> <select name="action" class="form-control">` + options + `</select>
<input name="proto" class="d-none" value="` + split[1] + `"> <input name="proto" class="d-none" value="` + split[0] + `">
<input name="server" class="d-none" value="` + split[3] + `"> <input name="server" class="d-none" value="` + split[2] + `">
<input name="target" class="form-control" placeholder="Target" aria-label="Target" value="` + target + `"> <input name="target" class="form-control" placeholder="Target" aria-label="Target" value="` + target + `">
<div class="input-group-append"> <div class="input-group-append">
<button class="btn btn-outline-success" type="submit">&raquo;</button> <button class="btn btn-outline-success" type="submit">&raquo;</button>
@ -179,7 +141,7 @@ func templateHeader(w http.ResponseWriter, r *http.Request, title string) {
// Print HTML footer to http response // Print HTML footer to http response
func templateFooter(w http.ResponseWriter) { func templateFooter(w http.ResponseWriter) {
w.Write([]byte(` w.Write([]byte(`
</div> </div>
</body> </body>
</html> </html>
@ -189,120 +151,112 @@ func templateFooter(w http.ResponseWriter) {
// Write the given text to http response, and add whois links for // Write the given text to http response, and add whois links for
// ASNs and IP addresses // ASNs and IP addresses
func smartWriter(w http.ResponseWriter, s string) { func smartWriter(w http.ResponseWriter, s string) {
w.Write([]byte("<pre>")) w.Write([]byte("<pre>"))
for _, line := range strings.Split(s, "\n") { for _, line := range strings.Split(s, "\n") {
var tabPending bool = false var isASes bool = false
var isFirstWord bool = true
var isASes bool = false
for _, word := range strings.Split(line, " ") {
// Process each word
if len(word) == 0 {
// Indicates that two spaces are connected together
// Replace this with a tab later
tabPending = true
} else {
if isFirstWord {
// Do not add space before the first word
isFirstWord = false
} else if tabPending {
// A tab should be added; add it
w.Write([]byte("\t"))
tabPending = false
} else {
// Two words separated by a space, just print the space
w.Write([]byte(" "))
}
if isIP(word) { var lineFormatted string
// Add whois link to the IP, handles IPv4 and IPv6 words := strings.Split(line, " ")
w.Write([]byte("<a href=\"/whois/" + word + "\">" + word + "</a>"))
} else if len(strings.Split(word, "%")) == 2 && isIP(strings.Split(word, "%")[0]) { for wordID, word := range words {
// IPv6 link-local with interface name, like fd00::1%eth0 if len(word) == 0 {
// Add whois link to address part continue
w.Write([]byte("<a href=\"/whois/" + strings.Split(word, "%")[0] + "\">" + strings.Split(word, "%")[0] + "</a>")) }
w.Write([]byte("%" + strings.Split(word, "%")[1])) if wordID > 0 && (len(words[wordID-1]) == 0 || words[wordID-1][len(words[wordID-1])-1] == ':') {
} else if len(strings.Split(word, "/")) == 2 && isIP(strings.Split(word, "/")[0]) { // Insert TAB if there are multiple spaces before this word
// IP with a CIDR range, like 192.168.0.1/24 lineFormatted += "\t"
// Add whois link to first part } else {
w.Write([]byte("<a href=\"/whois/" + strings.Split(word, "/")[0] + "\">" + strings.Split(word, "/")[0] + "</a>")) lineFormatted += " "
w.Write([]byte("/" + strings.Split(word, "/")[1])) }
} else if word == "AS:" || word == "\tBGP.as_path:" {
// Bird will output ASNs later if isIP(word) {
isASes = true // Add whois link to the IP, handles IPv4 and IPv6
w.Write([]byte(word)) lineFormatted += "<a href=\"/whois/" + word + "\">" + word + "</a>"
} else if isASes && isNumber(word) { } else if len(strings.Split(word, "%")) == 2 && isIP(strings.Split(word, "%")[0]) {
// Bird is outputing ASNs, ass whois for them // IPv6 link-local with interface name, like fd00::1%eth0
w.Write([]byte("<a href=\"/whois/AS" + word + "\">" + word + "</a>")) // Add whois link to address part
} else { lineFormatted += "<a href=\"/whois/" + strings.Split(word, "%")[0] + "\">" + strings.Split(word, "%")[0] + "</a>"
// Just an ordinary word, print it and done lineFormatted += "%" + strings.Split(word, "%")[1]
w.Write([]byte(word)) } else if len(strings.Split(word, "/")) == 2 && isIP(strings.Split(word, "/")[0]) {
} // IP with a CIDR range, like 192.168.0.1/24
} // Add whois link to first part
} lineFormatted += "<a href=\"/whois/" + strings.Split(word, "/")[0] + "\">" + strings.Split(word, "/")[0] + "</a>"
w.Write([]byte("\n")) lineFormatted += "/" + strings.Split(word, "/")[1]
} } else if word == "AS:" || word == "\tBGP.as_path:" {
w.Write([]byte("</pre>")) // Bird will output ASNs later
isASes = true
lineFormatted += word
} else if isASes && isNumber(word) {
// Bird is outputing ASNs, ass whois for them
lineFormatted += "<a href=\"/whois/AS" + word + "\">" + word + "</a>"
} else {
// Just an ordinary word, print it and done
lineFormatted += word
}
}
lineFormatted += "\n"
w.Write([]byte(lineFormatted))
}
w.Write([]byte("</pre>"))
} }
// Output a table for the summary page // Output a table for the summary page
func summaryTable(w http.ResponseWriter, isIPv6 bool, data string, serverName string) { func summaryTable(w http.ResponseWriter, isIPv6 bool, data string, serverName string) {
w.Write([]byte("<table class=\"table table-striped table-bordered table-sm\">")) // w.Write([]byte("<pre>" + data + "</pre>"))
for lineId, line := range strings.Split(data, "\n") { w.Write([]byte("<table class=\"table table-striped table-bordered table-sm\">"))
var tabPending bool = false for lineID, line := range strings.Split(data, "\n") {
var tableCells int = 0 var row [6]string
var row [6]string var rowIndex int = 0
for i, word := range strings.Split(line, " ") {
if len(word) == 0 {
tabPending = true
} else {
if i == 0 {
tabPending = true
} else if tabPending {
// Allow up to 6 columns in the table, any more is ignored
if tableCells < 5 {
tableCells++
} else {
row[tableCells] += " "
}
tabPending = false
} else {
row[tableCells] += " "
}
row[tableCells] += word
}
}
// Ignore empty lines words := strings.Split(line, " ")
if len(row[0]) == 0 { for wordID, word := range words {
continue if len(word) == 0 {
} continue
}
if rowIndex < 4 {
row[rowIndex] += word
rowIndex++
} else if len(words[wordID-1]) == 0 && rowIndex < len(row)-1 {
if len(row[rowIndex]) > 0 {
rowIndex++
}
row[rowIndex] += word
} else {
row[rowIndex] += " " + word
}
}
if lineId == 0 { // Ignore empty lines
// Draw the table head if len(row[0]) == 0 {
w.Write([]byte("<thead>")) continue
for i := 0; i < 6; i++ { }
w.Write([]byte("<th scope=\"col\">" + row[i] + "</th>"))
} if lineID == 0 {
w.Write([]byte("</thead><tbody>")) // Draw the table head
} else { w.Write([]byte("<thead>"))
// Draw the row in red if the link isn't up for i := 0; i < 6; i++ {
if row[3] == "up" { w.Write([]byte("<th scope=\"col\">" + row[i] + "</th>"))
w.Write([]byte("<tr>")) }
} else if lineId != 0 { w.Write([]byte("</thead><tbody>"))
w.Write([]byte("<tr class=\"table-danger\">")) } else {
} // Draw the row in red if the link isn't up
// Add link to detail for first column w.Write([]byte("<tr class=\"" + (map[string]string{
if isIPv6 { "up": "table-success",
w.Write([]byte("<td><a href=\"/ipv6/detail/" + serverName + "/" + row[0] + "\">" + row[0] + "</a></td>")) "down": "table-danger",
} else { "start": "table-danger",
w.Write([]byte("<td><a href=\"/ipv4/detail/" + serverName + "/" + row[0] + "\">" + row[0] + "</a></td>")) })[row[3]] + "\">"))
} // Add link to detail for first column
// Draw the other cells if isIPv6 {
for i := 1; i < 6; i++ { w.Write([]byte("<td><a href=\"/ipv6/detail/" + serverName + "/" + row[0] + "\">" + row[0] + "</a></td>"))
w.Write([]byte("<td>" + row[i] + "</td>")) } else {
} w.Write([]byte("<td><a href=\"/ipv4/detail/" + serverName + "/" + row[0] + "\">" + row[0] + "</a></td>"))
w.Write([]byte("</tr>")) }
} // Draw the other cells
} for i := 1; i < 6; i++ {
w.Write([]byte("</tbody></table>")) w.Write([]byte("<td>" + row[i] + "</td>"))
}
w.Write([]byte("</tr>"))
}
}
w.Write([]byte("</tbody></table>"))
} }

205
frontend/webserver.go
View File

@ -1,144 +1,87 @@
package main package main
import ( import (
"net/http" "html"
"strings" "net/http"
"html" "strings"
) )
func webDispatcherIPv4Summary(w http.ResponseWriter, r *http.Request) { func webHandlerWhois(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/summary/"):], "/") var target string = r.URL.Path[len("/whois/"):]
webHandler(w, r, "bird", split[0], "show protocols")
templateHeader(w, r, "Bird-lg Go - whois "+html.EscapeString(target))
w.Write([]byte("<h2>whois " + html.EscapeString(target) + "</h2>"))
smartWriter(w, whois(target))
templateFooter(w)
} }
func webDispatcherIPv6Summary(w http.ResponseWriter, r *http.Request) { func webBackendCommunicator(w http.ResponseWriter, r *http.Request, endpoint string, command string) {
split := strings.Split(r.URL.Path[len("/ipv6/summary/"):], "/") split := strings.Split(r.URL.Path[1:], "/")
webHandler(w, r, "bird6", split[0], "show protocols") urlCommands := strings.Join(split[3:], "/")
command = (map[string]string{
"summary": "show protocols",
"detail": "show protocols all " + urlCommands,
"route": "show route for " + urlCommands,
"route_all": "show route for " + urlCommands + " all",
"route_where": "show route where net ~ [ " + urlCommands + " ]",
"route_where_all": "show route where net ~ [ " + urlCommands + " ] all",
"traceroute": urlCommands,
})[command]
templateHeader(w, r, "Bird-lg Go - "+html.EscapeString(endpoint+" "+command))
var servers []string = strings.Split(split[2], "+")
var responses []string = batchRequest(servers, endpoint, command)
for i, response := range responses {
w.Write([]byte("<h2>" + html.EscapeString(servers[i]) + ": " + html.EscapeString(command) + "</h2>"))
if (endpoint == "bird" || endpoint == "bird6") && command == "show protocols" && len(response) > 4 && strings.ToLower(response[0:4]) == "name" {
var isIPv6 bool = endpoint[len(endpoint)-1] == '6'
summaryTable(w, isIPv6, response, servers[i])
} else {
smartWriter(w, response)
}
}
templateFooter(w)
} }
func webDispatcherIPv4Detail(w http.ResponseWriter, r *http.Request) { func webHandlerNavbarFormRedirect(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/detail/"):], "/") query := r.URL.Query()
webHandler(w, r, "bird", split[0], "show protocols all " + split[1]) if query.Get("action") == "whois" {
} http.Redirect(w, r, "/"+query.Get("action")+"/"+query.Get("target"), 302)
} else if query.Get("action") == "summary" {
func webDispatcherIPv6Detail(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, "/"+query.Get("proto")+"/"+query.Get("action")+"/"+query.Get("server"), 302)
split := strings.Split(r.URL.Path[len("/ipv6/detail/"):], "/") } else {
webHandler(w, r, "bird6", split[0], "show protocols all " + split[1]) http.Redirect(w, r, "/"+query.Get("proto")+"/"+query.Get("action")+"/"+query.Get("server")+"/"+query.Get("target"), 302)
} }
func webDispatcherIPv4Route(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/route/"):], "/")
webHandler(w, r, "bird", split[0], "show route for " + strings.Join(split[1:], "/"))
}
func webDispatcherIPv6Route(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv6/route/"):], "/")
webHandler(w, r, "bird6", split[0], "show route for " + strings.Join(split[1:], "/"))
}
func webDispatcherIPv4RouteAll(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/route_all/"):], "/")
webHandler(w, r, "bird", split[0], "show route for " + strings.Join(split[1:], "/") + " all")
}
func webDispatcherIPv6RouteAll(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv6/route_all/"):], "/")
webHandler(w, r, "bird6", split[0], "show route for " + strings.Join(split[1:], "/") + " all")
}
func webDispatcherIPv4RouteWhere(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/route_where/"):], "/")
webHandler(w, r, "bird", split[0], "show route where net ~ [ " + strings.Join(split[1:], "/") + " ]")
}
func webDispatcherIPv6RouteWhere(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv6/route_where/"):], "/")
webHandler(w, r, "bird6", split[0], "show route where net ~ [ " + strings.Join(split[1:], "/") + " ]")
}
func webDispatcherIPv4RouteWhereAll(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/route_where_all/"):], "/")
webHandler(w, r, "bird", split[0], "show route where net ~ [ " + strings.Join(split[1:], "/") + " ] all")
}
func webDispatcherIPv6RouteWhereAll(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv6/route_where_all/"):], "/")
webHandler(w, r, "bird6", split[0], "show route where net ~ [ " + strings.Join(split[1:], "/") + " ] all")
}
func webDispatcherWhois(w http.ResponseWriter, r *http.Request) {
var target string = r.URL.Path[len("/whois/"):]
templateHeader(w, r, "Bird-lg Go - whois " + html.EscapeString(target))
w.Write([]byte("<h2>whois " + html.EscapeString(target) + "</h2>"))
smartWriter(w, whois(target))
templateFooter(w)
}
func webDispatcherIPv4Traceroute(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv4/traceroute/"):], "/")
webHandler(w, r, "traceroute", split[0], strings.Join(split[1:], "/"))
}
func webDispatcherIPv6Traceroute(w http.ResponseWriter, r *http.Request) {
split := strings.Split(r.URL.Path[len("/ipv6/traceroute/"):], "/")
webHandler(w, r, "traceroute6", split[0], strings.Join(split[1:], "/"))
}
func webHandler(w http.ResponseWriter, r *http.Request, endpoint string, serverQuery string, command string) {
templateHeader(w, r, "Bird-lg Go - " + html.EscapeString(endpoint + " " + command))
var servers []string = strings.Split(serverQuery, "+")
var responses []string = batchRequest(servers, endpoint, command)
for i, response := range responses {
w.Write([]byte("<h2>" + html.EscapeString(servers[i]) + ": " + html.EscapeString(command) + "</h2>"))
if (endpoint == "bird" || endpoint == "bird6") && command == "show protocols" && strings.ToLower(response[0:4]) == "name" {
var isIPv6 bool = endpoint[len(endpoint) - 1] == '6'
summaryTable(w, isIPv6, response, servers[i])
} else {
smartWriter(w, response)
}
}
templateFooter(w)
}
func defaultRedirect(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/ipv4/summary/" + strings.Join(settingServers[:], "+"), 302)
}
func navbarFormRedirect(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
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)
} else {
http.Redirect(w, r, "/" + query.Get("proto") + "/" + query.Get("action") + "/" + query.Get("server") + "/" + query.Get("target"), 302)
}
} }
func webServerStart() { func webServerStart() {
// Start HTTP server // Start HTTP server
http.HandleFunc("/", defaultRedirect) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.HandleFunc("/ipv4/summary/", webDispatcherIPv4Summary) http.Redirect(w, r, "/ipv4/summary/"+strings.Join(settingServers[:], "+"), 302)
http.HandleFunc("/ipv6/summary/", webDispatcherIPv6Summary) })
http.HandleFunc("/ipv4/detail/", webDispatcherIPv4Detail) http.HandleFunc("/ipv4/summary/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "summary") })
http.HandleFunc("/ipv6/detail/", webDispatcherIPv6Detail) http.HandleFunc("/ipv6/summary/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "summary") })
http.HandleFunc("/ipv4/route/", webDispatcherIPv4Route) http.HandleFunc("/ipv4/detail/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "detail") })
http.HandleFunc("/ipv6/route/", webDispatcherIPv6Route) http.HandleFunc("/ipv6/detail/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "detail") })
http.HandleFunc("/ipv4/route_all/", webDispatcherIPv4RouteAll) http.HandleFunc("/ipv4/route/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "route") })
http.HandleFunc("/ipv6/route_all/", webDispatcherIPv6RouteAll) http.HandleFunc("/ipv6/route/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "route") })
http.HandleFunc("/ipv4/route_where/", webDispatcherIPv4RouteWhere) http.HandleFunc("/ipv4/route_all/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "route_all") })
http.HandleFunc("/ipv6/route_where/", webDispatcherIPv6RouteWhere) http.HandleFunc("/ipv6/route_all/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "route_all") })
http.HandleFunc("/ipv4/route_where_all/", webDispatcherIPv4RouteWhereAll) http.HandleFunc("/ipv4/route_where/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "route_where") })
http.HandleFunc("/ipv6/route_where_all/", webDispatcherIPv6RouteWhereAll) http.HandleFunc("/ipv6/route_where/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "route_where") })
http.HandleFunc("/ipv4/traceroute/", webDispatcherIPv4Traceroute) http.HandleFunc("/ipv4/route_where_all/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird", "route_where_all") })
http.HandleFunc("/ipv6/traceroute/", webDispatcherIPv6Traceroute) http.HandleFunc("/ipv6/route_where_all/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "bird6", "route_where_all") })
http.HandleFunc("/whois/", webDispatcherWhois) http.HandleFunc("/ipv4/traceroute/", func(w http.ResponseWriter, r *http.Request) { webBackendCommunicator(w, r, "traceroute", "traceroute") })
http.HandleFunc("/redir/", navbarFormRedirect) http.HandleFunc("/ipv6/traceroute/", func(w http.ResponseWriter, r *http.Request) {
http.ListenAndServe(settingListen, nil) webBackendCommunicator(w, r, "traceroute6", "traceroute")
})
http.HandleFunc("/whois/", webHandlerWhois)
http.HandleFunc("/redir/", webHandlerNavbarFormRedirect)
http.ListenAndServe(settingListen, nil)
} }

144
proxy/bird.go
View File

@ -1,10 +1,10 @@
package main package main
import ( import (
"io" "io"
"net" "net"
"net/http" "net/http"
"sync" "sync"
) )
// BIRDv4 connection & mutex lock // BIRDv4 connection & mutex lock
@ -18,83 +18,93 @@ var bird6Mutex = &sync.Mutex{}
// Read a line from bird socket, removing preceding status number, output it. // Read a line from bird socket, removing preceding status number, output it.
// Returns if there are more lines. // Returns if there are more lines.
func birdReadln(bird io.Reader, w io.Writer) bool { func birdReadln(bird io.Reader, w io.Writer) bool {
// Read from socket byte by byte, until reaching newline character // Read from socket byte by byte, until reaching newline character
c := make([]byte, 1024, 1024) c := make([]byte, 1024, 1024)
pos := 0 pos := 0
for { for {
if pos >= 1024 { break } if pos >= 1024 {
_, err := bird.Read(c[pos:pos+1]) break
if err != nil { }
panic(err) _, err := bird.Read(c[pos : pos+1])
} if err != nil {
if c[pos] == byte('\n') { panic(err)
break }
} if c[pos] == byte('\n') {
pos++ break
} }
pos++
}
c = c[:pos+1] c = c[:pos+1]
// print(string(c[:])) // print(string(c[:]))
// Remove preceding status number, different situations // Remove preceding status number, different situations
if pos < 4 { if pos < 4 {
// Line is too short to have a status number // Line is too short to have a status number
if w != nil { if w != nil {
pos = 0 pos = 0
for c[pos] == byte(' ') { pos++ } for c[pos] == byte(' ') {
w.Write(c[pos:]) pos++
} }
return true w.Write(c[pos:])
} else if isNumeric(c[0]) && isNumeric(c[1]) && isNumeric(c[2]) && isNumeric(c[3]) { }
// There is a status number at beginning, remove first 5 bytes return true
if w != nil && pos > 6 { } else if isNumeric(c[0]) && isNumeric(c[1]) && isNumeric(c[2]) && isNumeric(c[3]) {
pos = 5 // There is a status number at beginning, remove first 5 bytes
for c[pos] == byte(' ') { pos++ } if w != nil && pos > 6 {
w.Write(c[pos:]) pos = 5
} for c[pos] == byte(' ') {
return c[0] != byte('0') && c[0] != byte('8') && c[0] != byte('9') pos++
} else { }
// There is no status number, only remove preceding spaces w.Write(c[pos:])
if w != nil { }
pos = 0 return c[0] != byte('0') && c[0] != byte('8') && c[0] != byte('9')
for c[pos] == byte(' ') { pos++ } } else {
w.Write(c[pos:]) // There is no status number, only remove preceding spaces
} if w != nil {
return true pos = 0
} for c[pos] == byte(' ') {
pos++
}
w.Write(c[pos:])
}
return true
}
} }
// Write a command to a bird socket // Write a command to a bird socket
func birdWriteln(bird io.Writer, s string) { func birdWriteln(bird io.Writer, s string) {
bird.Write([]byte(s + "\n")) bird.Write([]byte(s + "\n"))
} }
// Handles BIRDv4 queries // Handles BIRDv4 queries
func birdHandler(httpW http.ResponseWriter, httpR *http.Request) { func birdHandler(httpW http.ResponseWriter, httpR *http.Request) {
query := string(httpR.URL.Query().Get("q")) query := string(httpR.URL.Query().Get("q"))
if query == "" { if query == "" {
invalidHandler(httpW, httpR) invalidHandler(httpW, httpR)
} else { } else {
birdMutex.Lock() birdMutex.Lock()
defer birdMutex.Unlock() defer birdMutex.Unlock()
println(query) println(query)
birdWriteln(bird, query) birdWriteln(bird, query)
for birdReadln(bird, httpW) {} for birdReadln(bird, httpW) {
} }
}
} }
// Handles BIRDv6 queries // Handles BIRDv6 queries
func bird6Handler(httpW http.ResponseWriter, httpR *http.Request) { func bird6Handler(httpW http.ResponseWriter, httpR *http.Request) {
query := string(httpR.URL.Query().Get("q")) query := string(httpR.URL.Query().Get("q"))
if query == "" { if query == "" {
invalidHandler(httpW, httpR) invalidHandler(httpW, httpR)
} else { } else {
bird6Mutex.Lock() bird6Mutex.Lock()
defer bird6Mutex.Unlock() defer bird6Mutex.Unlock()
println(query) println(query)
birdWriteln(bird6, query) birdWriteln(bird6, query)
for birdReadln(bird6, httpW) {} for birdReadln(bird6, httpW) {
} }
}
} }

102
proxy/main.go
View File

@ -1,75 +1,75 @@
package main package main
import ( import (
"net" "flag"
"net/http" "net"
"flag" "net/http"
"os" "os"
) )
// Check if a byte is character for number // Check if a byte is character for number
func isNumeric(b byte) bool { func isNumeric(b byte) bool {
return b >= byte('0') && b <= byte('9') return b >= byte('0') && b <= byte('9')
} }
// Default handler, returns 500 Internal Server Error // Default handler, returns 500 Internal Server Error
func invalidHandler(httpW http.ResponseWriter, httpR *http.Request) { func invalidHandler(httpW http.ResponseWriter, httpR *http.Request) {
httpW.WriteHeader(http.StatusInternalServerError) httpW.WriteHeader(http.StatusInternalServerError)
httpW.Write([]byte("Invalid Request\n")) httpW.Write([]byte("Invalid Request\n"))
} }
// Wrapper of tracer // Wrapper of tracer
func main() { func main() {
var err error var err error
// Prepare default socket paths, use environment variable if possible // Prepare default socket paths, use environment variable if possible
birdSocketDefault := "/var/run/bird/bird.ctl" birdSocketDefault := "/var/run/bird/bird.ctl"
bird6SocketDefault := "/var/run/bird/bird6.ctl" bird6SocketDefault := "/var/run/bird/bird6.ctl"
listenDefault := ":8000" listenDefault := ":8000"
if birdSocketEnv := os.Getenv("BIRD_SOCKET"); birdSocketEnv != "" { if birdSocketEnv := os.Getenv("BIRD_SOCKET"); birdSocketEnv != "" {
birdSocketDefault = birdSocketEnv birdSocketDefault = birdSocketEnv
} }
if bird6SocketEnv := os.Getenv("BIRD6_SOCKET"); bird6SocketEnv != "" { if bird6SocketEnv := os.Getenv("BIRD6_SOCKET"); bird6SocketEnv != "" {
bird6SocketDefault = bird6SocketEnv bird6SocketDefault = bird6SocketEnv
} }
if listenEnv := os.Getenv("BIRDLG_LISTEN"); listenEnv != "" { if listenEnv := os.Getenv("BIRDLG_LISTEN"); listenEnv != "" {
listenDefault = listenEnv listenDefault = listenEnv
} }
// Allow parameters to override environment variables // Allow parameters to override environment variables
birdParam := flag.String("bird", birdSocketDefault, "socket file for bird, set either in parameter or environment variable BIRD_SOCKET") birdParam := flag.String("bird", birdSocketDefault, "socket file for bird, set either in parameter or environment variable BIRD_SOCKET")
bird6Param := flag.String("bird6", bird6SocketDefault, "socket file for bird6, set either in parameter or environment variable BIRD6_SOCKET") bird6Param := flag.String("bird6", bird6SocketDefault, "socket file for bird6, set either in parameter or environment variable BIRD6_SOCKET")
listenParam := flag.String("listen", listenDefault, "listen address, set either in parameter or environment variable BIRDLG_LISTEN") listenParam := flag.String("listen", listenDefault, "listen address, set either in parameter or environment variable BIRDLG_LISTEN")
flag.Parse() flag.Parse()
// Initialize BIRDv4 socket // Initialize BIRDv4 socket
bird, err = net.Dial("unix", *birdParam) bird, err = net.Dial("unix", *birdParam)
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer bird.Close() defer bird.Close()
birdReadln(bird, nil) birdReadln(bird, nil)
birdWriteln(bird, "restrict") birdWriteln(bird, "restrict")
birdReadln(bird, nil) birdReadln(bird, nil)
// Initialize BIRDv6 socket // Initialize BIRDv6 socket
bird6, err = net.Dial("unix", *bird6Param) bird6, err = net.Dial("unix", *bird6Param)
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer bird6.Close() defer bird6.Close()
birdReadln(bird6, nil) birdReadln(bird6, nil)
birdWriteln(bird6, "restrict") birdWriteln(bird6, "restrict")
birdReadln(bird6, nil) birdReadln(bird6, nil)
// Start HTTP server // Start HTTP server
http.HandleFunc("/", invalidHandler) http.HandleFunc("/", invalidHandler)
http.HandleFunc("/bird", birdHandler) http.HandleFunc("/bird", birdHandler)
http.HandleFunc("/bird6", bird6Handler) http.HandleFunc("/bird6", bird6Handler)
http.HandleFunc("/traceroute", tracerouteIPv4Wrapper) http.HandleFunc("/traceroute", tracerouteIPv4Wrapper)
http.HandleFunc("/traceroute6", tracerouteIPv6Wrapper) http.HandleFunc("/traceroute6", tracerouteIPv6Wrapper)
http.ListenAndServe(*listenParam, nil) http.ListenAndServe(*listenParam, nil)
} }

110
proxy/traceroute.go
View File

@ -1,67 +1,75 @@
package main package main
import ( import (
"net/http" "net/http"
"runtime" "os/exec"
"os/exec" "runtime"
) )
// Wrapper of traceroute, IPv4 // Wrapper of traceroute, IPv4
func tracerouteIPv4Wrapper(httpW http.ResponseWriter, httpR *http.Request) { func tracerouteIPv4Wrapper(httpW http.ResponseWriter, httpR *http.Request) {
tracerouteRealHandler(false, httpW, httpR) tracerouteRealHandler(false, httpW, httpR)
} }
// Wrapper of traceroute, IPv6 // Wrapper of traceroute, IPv6
func tracerouteIPv6Wrapper(httpW http.ResponseWriter, httpR *http.Request) { func tracerouteIPv6Wrapper(httpW http.ResponseWriter, httpR *http.Request) {
tracerouteRealHandler(true, httpW, httpR) tracerouteRealHandler(true, httpW, httpR)
} }
// Real handler of traceroute requests // Real handler of traceroute requests
func tracerouteRealHandler(useIPv6 bool, httpW http.ResponseWriter, httpR *http.Request) { func tracerouteRealHandler(useIPv6 bool, httpW http.ResponseWriter, httpR *http.Request) {
query := string(httpR.URL.Query().Get("q")) query := string(httpR.URL.Query().Get("q"))
if query == "" { if query == "" {
invalidHandler(httpW, httpR) invalidHandler(httpW, httpR)
} else { } else {
var cmd string var cmd string
var args []string var args []string
if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" { if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
if useIPv6 { cmd = "traceroute6" } else { cmd = "traceroute" } if useIPv6 {
args = []string{"-a", "-q1", "-w1", "-m15", query} cmd = "traceroute6"
} else if runtime.GOOS == "openbsd" { } else {
if useIPv6 { cmd = "traceroute6" } else { cmd = "traceroute" } cmd = "traceroute"
args = []string{"-A", "-q1", "-w1", "-m15", query} }
} else if runtime.GOOS == "linux" { args = []string{"-a", "-q1", "-w1", "-m15", query}
cmd = "traceroute" } else if runtime.GOOS == "openbsd" {
if useIPv6 { if useIPv6 {
args = []string{"-6", "-A", "-q1", "-N32", "-w1", "-m15", query} cmd = "traceroute6"
} else { } else {
args = []string{"-4", "-A", "-q1", "-N32", "-w1", "-m15", query} cmd = "traceroute"
} }
} else { args = []string{"-A", "-q1", "-w1", "-m15", query}
httpW.WriteHeader(http.StatusInternalServerError) } else if runtime.GOOS == "linux" {
httpW.Write([]byte("Traceroute Not Supported\n")) cmd = "traceroute"
return if useIPv6 {
} args = []string{"-6", "-A", "-q1", "-N32", "-w1", "-m15", query}
instance := exec.Command(cmd, args...) } else {
output, err := instance.Output() args = []string{"-4", "-A", "-q1", "-N32", "-w1", "-m15", query}
if err != nil && runtime.GOOS == "linux" { }
// Standard traceroute utility failed, maybe system using busybox } else {
// Run with less parameters httpW.WriteHeader(http.StatusInternalServerError)
cmd = "traceroute" httpW.Write([]byte("Traceroute Not Supported\n"))
if useIPv6 { return
args = []string{"-6", "-q1", "-w1", "-m15", query} }
} else { instance := exec.Command(cmd, args...)
args = []string{"-4", "-q1", "-w1", "-m15", query} output, err := instance.Output()
} if err != nil && runtime.GOOS == "linux" {
instance = exec.Command(cmd, args...) // Standard traceroute utility failed, maybe system using busybox
output, err = instance.Output() // Run with less parameters
} cmd = "traceroute"
if err != nil { if useIPv6 {
httpW.WriteHeader(http.StatusInternalServerError) args = []string{"-6", "-q1", "-w1", "-m15", query}
httpW.Write([]byte("Traceroute Execution Error: ")) } else {
httpW.Write([]byte(err.Error() + "\n")) args = []string{"-4", "-q1", "-w1", "-m15", query}
return }
} instance = exec.Command(cmd, args...)
httpW.Write(output) output, err = instance.Output()
} }
if err != nil {
httpW.WriteHeader(http.StatusInternalServerError)
httpW.Write([]byte("Traceroute Execution Error: "))
httpW.Write([]byte(err.Error() + "\n"))
return
}
httpW.Write(output)
}
} }