echoip/http/http.go

463 lines
12 KiB
Go
Raw Normal View History

2018-02-10 13:24:32 +01:00
package http
2015-09-17 20:57:27 +02:00
import (
"encoding/json"
"fmt"
2016-04-15 20:14:16 +02:00
"html/template"
2020-09-11 21:16:43 +02:00
"io/ioutil"
2020-12-09 21:08:06 +01:00
"log"
2018-03-18 22:15:51 +01:00
"path/filepath"
2018-08-14 21:04:58 +02:00
"strings"
2016-08-13 20:32:19 +02:00
2020-09-05 22:07:35 +02:00
"net/http/pprof"
2018-08-27 20:33:29 +02:00
"github.com/mpolden/echoip/iputil"
"github.com/mpolden/echoip/iputil/geo"
"github.com/mpolden/echoip/useragent"
2016-08-13 20:32:19 +02:00
"math/big"
2015-09-17 20:57:27 +02:00
"net"
"net/http"
2016-04-15 20:52:15 +02:00
"strconv"
2015-09-17 20:57:27 +02:00
)
const (
jsonMediaType = "application/json"
textMediaType = "text/plain"
)
2015-09-17 20:57:27 +02:00
2018-02-10 13:24:32 +01:00
type Server struct {
2018-02-10 14:35:12 +01:00
Template string
IPHeaders []string
2018-03-19 19:54:24 +01:00
LookupAddr func(net.IP) (string, error)
2018-02-11 11:19:50 +01:00
LookupPort func(net.IP, uint64) error
2019-12-25 21:04:26 +01:00
cache *Cache
2018-08-14 21:00:46 +02:00
gr geo.Reader
2020-09-05 12:21:02 +02:00
profile bool
2015-09-17 20:57:27 +02:00
}
2016-04-15 20:14:16 +02:00
type Response struct {
2019-07-14 00:50:31 +02:00
IP net.IP `json:"ip"`
IPDecimal *big.Int `json:"ip_decimal"`
Country string `json:"country,omitempty"`
CountryISO string `json:"country_iso,omitempty"`
2020-05-10 14:23:50 +02:00
CountryEU *bool `json:"country_eu,omitempty"`
RegionName string `json:"region_name,omitempty"`
RegionCode string `json:"region_code,omitempty"`
MetroCode uint `json:"metro_code,omitempty"`
PostalCode string `json:"zip_code,omitempty"`
2019-07-14 00:50:31 +02:00
City string `json:"city,omitempty"`
Latitude float64 `json:"latitude,omitempty"`
Longitude float64 `json:"longitude,omitempty"`
2020-05-10 14:23:50 +02:00
Timezone string `json:"time_zone,omitempty"`
2019-07-14 00:50:31 +02:00
ASN string `json:"asn,omitempty"`
ASNOrg string `json:"asn_org,omitempty"`
2020-05-10 14:23:50 +02:00
Hostname string `json:"hostname,omitempty"`
2019-07-14 00:50:31 +02:00
UserAgent *useragent.UserAgent `json:"user_agent,omitempty"`
2016-04-15 20:14:16 +02:00
}
2016-04-27 17:07:53 +02:00
type PortResponse struct {
2016-04-15 20:52:15 +02:00
IP net.IP `json:"ip"`
Port uint64 `json:"port"`
Reachable bool `json:"reachable"`
}
2020-09-05 12:21:02 +02:00
func New(db geo.Reader, cache *Cache, profile bool) *Server {
return &Server{cache: cache, gr: db, profile: profile}
2016-07-06 23:44:33 +02:00
}
2018-08-14 21:04:58 +02:00
func ipFromForwardedForHeader(v string) string {
2018-08-14 21:32:29 +02:00
sep := strings.Index(v, ",")
if sep == -1 {
return v
2018-08-14 21:04:58 +02:00
}
2018-08-14 21:32:29 +02:00
return v[:sep]
2018-08-14 21:04:58 +02:00
}
// ipFromRequest detects the IP address for this transaction.
//
// * `headers` - the specific HTTP headers to trust
// * `r` - the incoming HTTP request
// * `customIP` - whether to allow the IP to be pulled from query parameters
func ipFromRequest(headers []string, r *http.Request, customIP bool) (net.IP, error) {
remoteIP := ""
if customIP && r.URL != nil {
if v, ok := r.URL.Query()["ip"]; ok {
remoteIP = v[0]
2018-08-14 21:04:58 +02:00
}
}
if remoteIP == "" {
for _, header := range headers {
remoteIP = r.Header.Get(header)
if http.CanonicalHeaderKey(header) == "X-Forwarded-For" {
remoteIP = ipFromForwardedForHeader(remoteIP)
}
if remoteIP != "" {
break
}
}
}
2016-04-16 10:45:43 +02:00
if remoteIP == "" {
host, _, err := net.SplitHostPort(r.RemoteAddr)
2015-09-17 20:57:27 +02:00
if err != nil {
return nil, err
}
2016-04-16 10:45:43 +02:00
remoteIP = host
2015-09-17 20:57:27 +02:00
}
2016-04-16 10:45:43 +02:00
ip := net.ParseIP(remoteIP)
2015-09-17 20:57:27 +02:00
if ip == nil {
2016-04-16 10:45:43 +02:00
return nil, fmt.Errorf("could not parse IP: %s", remoteIP)
2015-09-17 20:57:27 +02:00
}
return ip, nil
}
2020-06-07 23:16:35 +02:00
func userAgentFromRequest(r *http.Request) *useragent.UserAgent {
var userAgent *useragent.UserAgent
userAgentRaw := r.UserAgent()
if userAgentRaw != "" {
parsed := useragent.Parse(userAgentRaw)
userAgent = &parsed
}
return userAgent
}
2018-02-10 13:24:32 +01:00
func (s *Server) newResponse(r *http.Request) (Response, error) {
ip, err := ipFromRequest(s.IPHeaders, r, true)
2015-09-17 20:57:27 +02:00
if err != nil {
2016-04-15 20:14:16 +02:00
return Response{}, err
2015-09-17 20:57:27 +02:00
}
2019-12-25 21:04:26 +01:00
response, ok := s.cache.Get(ip)
if ok {
2020-09-05 22:07:35 +02:00
// Do not cache user agent
2020-06-07 23:16:35 +02:00
response.UserAgent = userAgentFromRequest(r)
2020-09-05 22:07:35 +02:00
return response, nil
2019-12-25 21:04:26 +01:00
}
2018-02-10 14:35:12 +01:00
ipDecimal := iputil.ToDecimal(ip)
2018-08-14 21:00:46 +02:00
country, _ := s.gr.Country(ip)
city, _ := s.gr.City(ip)
2019-07-05 15:01:45 +02:00
asn, _ := s.gr.ASN(ip)
2018-03-19 19:54:24 +01:00
var hostname string
2018-02-11 11:19:50 +01:00
if s.LookupAddr != nil {
2018-03-19 19:54:24 +01:00
hostname, _ = s.LookupAddr(ip)
2016-04-15 20:14:16 +02:00
}
2019-07-05 15:01:45 +02:00
var autonomousSystemNumber string
if asn.AutonomousSystemNumber > 0 {
autonomousSystemNumber = fmt.Sprintf("AS%d", asn.AutonomousSystemNumber)
}
2020-09-05 22:07:35 +02:00
response = Response{
2018-08-27 21:44:00 +02:00
IP: ip,
IPDecimal: ipDecimal,
Country: country.Name,
CountryISO: country.ISO,
CountryEU: country.IsEU,
2020-05-10 14:23:50 +02:00
RegionName: city.RegionName,
RegionCode: city.RegionCode,
MetroCode: city.MetroCode,
PostalCode: city.PostalCode,
2018-08-27 21:44:00 +02:00
City: city.Name,
Latitude: city.Latitude,
Longitude: city.Longitude,
2020-05-10 14:23:50 +02:00
Timezone: city.Timezone,
2019-07-05 15:01:45 +02:00
ASN: autonomousSystemNumber,
ASNOrg: asn.AutonomousSystemOrganization,
2020-05-10 14:23:50 +02:00
Hostname: hostname,
2019-12-25 21:04:26 +01:00
}
s.cache.Set(ip, response)
response.UserAgent = userAgentFromRequest(r)
2020-09-05 22:07:35 +02:00
return response, nil
2016-04-15 20:14:16 +02:00
}
2015-09-17 20:57:27 +02:00
2018-02-10 13:24:32 +01:00
func (s *Server) newPortResponse(r *http.Request) (PortResponse, error) {
2018-03-18 22:15:51 +01:00
lastElement := filepath.Base(r.URL.Path)
port, err := strconv.ParseUint(lastElement, 10, 16)
if err != nil || port < 1 || port > 65535 {
return PortResponse{Port: port}, fmt.Errorf("invalid port: %s", lastElement)
2016-04-27 17:07:53 +02:00
}
ip, err := ipFromRequest(s.IPHeaders, r, false)
2016-04-27 17:07:53 +02:00
if err != nil {
return PortResponse{Port: port}, err
}
2018-02-11 11:19:50 +01:00
err = s.LookupPort(ip, port)
2016-04-27 17:07:53 +02:00
return PortResponse{
IP: ip,
Port: port,
Reachable: err == nil,
}, nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) CLIHandler(w http.ResponseWriter, r *http.Request) *appError {
ip, err := ipFromRequest(s.IPHeaders, r, true)
2016-04-15 20:14:16 +02:00
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2015-09-17 20:57:27 +02:00
}
2017-05-28 19:20:02 +02:00
fmt.Fprintln(w, ip.String())
2016-04-16 09:18:21 +02:00
return nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) CLICountryHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
2016-04-16 09:18:21 +02:00
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2016-04-15 20:14:16 +02:00
}
2017-05-28 19:20:02 +02:00
fmt.Fprintln(w, response.Country)
2015-09-18 17:13:14 +02:00
return nil
2015-09-17 20:57:27 +02:00
}
2018-02-10 13:24:32 +01:00
func (s *Server) CLICountryISOHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
2018-02-09 20:41:30 +01:00
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2018-02-09 20:41:30 +01:00
}
fmt.Fprintln(w, response.CountryISO)
return nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) CLICityHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
2016-04-17 11:28:47 +02:00
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2016-04-17 11:28:47 +02:00
}
2017-05-28 19:20:02 +02:00
fmt.Fprintln(w, response.City)
2016-04-17 11:28:47 +02:00
return nil
}
2018-06-15 09:29:13 +02:00
func (s *Server) CLICoordinatesHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2018-06-15 09:29:13 +02:00
}
2018-08-27 21:48:08 +02:00
fmt.Fprintf(w, "%s,%s\n", formatCoordinate(response.Latitude), formatCoordinate(response.Longitude))
2018-06-15 09:29:13 +02:00
return nil
}
2019-07-05 15:01:45 +02:00
func (s *Server) CLIASNHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2019-07-05 15:01:45 +02:00
}
fmt.Fprintf(w, "%s\n", response.ASN)
return nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) JSONHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
2015-09-18 17:13:14 +02:00
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
2015-09-17 22:39:12 +02:00
}
b, err := json.MarshalIndent(response, "", " ")
2015-09-17 20:57:27 +02:00
if err != nil {
2016-04-15 20:14:16 +02:00
return internalServerError(err).AsJSON()
2015-09-17 20:57:27 +02:00
}
2016-05-26 21:38:10 +02:00
w.Header().Set("Content-Type", jsonMediaType)
2015-09-17 20:57:27 +02:00
w.Write(b)
2015-09-18 17:13:14 +02:00
return nil
2015-09-17 20:57:27 +02:00
}
2018-07-30 22:32:42 +02:00
func (s *Server) HealthHandler(w http.ResponseWriter, r *http.Request) *appError {
w.Header().Set("Content-Type", jsonMediaType)
w.Write([]byte(`{"status":"OK"}`))
return nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) PortHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newPortResponse(r)
2016-04-15 20:52:15 +02:00
if err != nil {
2019-01-16 22:16:05 +01:00
return badRequest(err).WithMessage(err.Error()).AsJSON()
2016-04-15 20:52:15 +02:00
}
b, err := json.MarshalIndent(response, "", " ")
2016-04-15 20:52:15 +02:00
if err != nil {
return internalServerError(err).AsJSON()
}
2016-05-26 21:38:10 +02:00
w.Header().Set("Content-Type", jsonMediaType)
2016-04-15 20:52:15 +02:00
w.Write(b)
return nil
}
2020-09-11 21:16:43 +02:00
func (s *Server) cacheResizeHandler(w http.ResponseWriter, r *http.Request) *appError {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
}
capacity, err := strconv.Atoi(string(body))
if err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
}
if err := s.cache.Resize(capacity); err != nil {
return badRequest(err).WithMessage(err.Error()).AsJSON()
}
data := struct {
Message string `json:"message"`
}{fmt.Sprintf("Changed cache capacity to %d.", capacity)}
b, err := json.MarshalIndent(data, "", " ")
2020-09-11 21:16:43 +02:00
if err != nil {
return internalServerError(err).AsJSON()
}
w.Header().Set("Content-Type", jsonMediaType)
w.Write(b)
return nil
}
2020-09-11 20:52:35 +02:00
func (s *Server) cacheHandler(w http.ResponseWriter, r *http.Request) *appError {
cacheStats := s.cache.Stats()
var data = struct {
2020-09-11 21:55:09 +02:00
Size int `json:"size"`
Capacity int `json:"capacity"`
Evictions uint64 `json:"evictions"`
2020-09-11 20:52:35 +02:00
}{
cacheStats.Size,
cacheStats.Capacity,
2020-09-11 21:55:09 +02:00
cacheStats.Evictions,
2020-09-11 20:52:35 +02:00
}
b, err := json.MarshalIndent(data, "", " ")
2020-09-11 20:52:35 +02:00
if err != nil {
return internalServerError(err).AsJSON()
}
w.Header().Set("Content-Type", jsonMediaType)
w.Write(b)
return nil
}
2018-02-10 13:24:32 +01:00
func (s *Server) DefaultHandler(w http.ResponseWriter, r *http.Request) *appError {
response, err := s.newResponse(r)
2015-09-18 17:42:43 +02:00
if err != nil {
return badRequest(err).WithMessage(err.Error())
2015-09-18 17:42:43 +02:00
}
2018-02-10 18:10:16 +01:00
t, err := template.ParseFiles(s.Template)
2015-09-18 17:13:14 +02:00
if err != nil {
2016-04-15 20:14:16 +02:00
return internalServerError(err)
2015-09-17 22:39:12 +02:00
}
2018-02-10 14:35:12 +01:00
json, err := json.MarshalIndent(response, "", " ")
if err != nil {
return internalServerError(err)
}
var data = struct {
Response
2018-10-28 16:42:17 +01:00
Host string
BoxLatTop float64
BoxLatBottom float64
BoxLonLeft float64
BoxLonRight float64
JSON string
Port bool
2018-02-10 14:35:12 +01:00
}{
response,
r.Host,
2018-10-28 16:42:17 +01:00
response.Latitude + 0.05,
response.Latitude - 0.05,
response.Longitude - 0.05,
response.Longitude + 0.05,
2018-02-10 14:35:12 +01:00
string(json),
2018-02-11 11:19:50 +01:00
s.LookupPort != nil,
2018-02-10 14:35:12 +01:00
}
if err := t.Execute(w, &data); err != nil {
2016-04-15 20:14:16 +02:00
return internalServerError(err)
2015-09-17 20:57:27 +02:00
}
2015-09-18 17:13:14 +02:00
return nil
2015-09-17 20:57:27 +02:00
}
2018-03-18 22:15:51 +01:00
func NotFoundHandler(w http.ResponseWriter, r *http.Request) *appError {
2016-04-15 20:14:16 +02:00
err := notFound(nil).WithMessage("404 page not found")
2016-05-26 21:38:10 +02:00
if r.Header.Get("accept") == jsonMediaType {
2016-04-15 20:14:16 +02:00
err = err.AsJSON()
}
return err
}
2018-03-18 22:15:51 +01:00
func cliMatcher(r *http.Request) bool {
2017-05-27 15:31:50 +02:00
ua := useragent.Parse(r.UserAgent())
switch ua.Product {
2020-07-24 00:41:07 +02:00
case "curl", "HTTPie", "httpie-go", "Wget", "fetch libfetch", "Go", "Go-http-client", "ddclient", "Mikrotik":
2017-05-27 15:31:50 +02:00
return true
}
return false
2015-09-17 20:57:27 +02:00
}
2015-09-18 17:13:14 +02:00
type appHandler func(http.ResponseWriter, *http.Request) *appError
2020-09-05 12:21:02 +02:00
func wrapHandlerFunc(f http.HandlerFunc) appHandler {
return func(w http.ResponseWriter, r *http.Request) *appError {
f.ServeHTTP(w, r)
return nil
}
}
2015-09-18 17:13:14 +02:00
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if e := fn(w, r); e != nil { // e is *appError
2020-12-09 21:08:06 +01:00
if e.Code/100 == 5 {
log.Println(e.Error)
}
2020-12-09 21:16:11 +01:00
// When Content-Type for error is JSON, we need to marshal the response into JSON
2015-09-18 17:13:14 +02:00
if e.IsJSON() {
var data = struct {
2020-12-09 21:16:11 +01:00
Code int `json:"status"`
2015-09-18 17:13:14 +02:00
Error string `json:"error"`
2020-12-09 21:16:11 +01:00
}{e.Code, e.Message}
b, err := json.MarshalIndent(data, "", " ")
2015-09-18 17:13:14 +02:00
if err != nil {
panic(err)
}
2016-04-15 20:14:16 +02:00
e.Message = string(b)
}
// Set Content-Type of response if set in error
if e.ContentType != "" {
w.Header().Set("Content-Type", e.ContentType)
2015-09-18 17:13:14 +02:00
}
w.WriteHeader(e.Code)
2017-05-28 19:20:02 +02:00
fmt.Fprint(w, e.Message)
2015-09-18 17:13:14 +02:00
}
}
2018-02-10 13:24:32 +01:00
func (s *Server) Handler() http.Handler {
2018-03-18 22:15:51 +01:00
r := NewRouter()
2015-09-17 20:57:27 +02:00
2018-07-30 22:32:42 +02:00
// Health
r.Route("GET", "/health", s.HealthHandler)
2015-09-17 20:57:27 +02:00
// JSON
2018-03-18 22:15:51 +01:00
r.Route("GET", "/", s.JSONHandler).Header("Accept", jsonMediaType)
r.Route("GET", "/json", s.JSONHandler)
2015-09-17 20:57:27 +02:00
// CLI
2018-03-18 22:15:51 +01:00
r.Route("GET", "/", s.CLIHandler).MatcherFunc(cliMatcher)
r.Route("GET", "/", s.CLIHandler).Header("Accept", textMediaType)
r.Route("GET", "/ip", s.CLIHandler)
2018-08-14 21:00:46 +02:00
if !s.gr.IsEmpty() {
2018-03-18 22:15:51 +01:00
r.Route("GET", "/country", s.CLICountryHandler)
r.Route("GET", "/country-iso", s.CLICountryISOHandler)
r.Route("GET", "/city", s.CLICityHandler)
2018-06-15 09:29:13 +02:00
r.Route("GET", "/coordinates", s.CLICoordinatesHandler)
2019-07-05 15:01:45 +02:00
r.Route("GET", "/asn", s.CLIASNHandler)
2018-02-10 17:52:55 +01:00
}
2015-09-17 20:57:27 +02:00
2016-04-15 20:14:16 +02:00
// Browser
2018-12-28 15:05:31 +01:00
if s.Template != "" {
r.Route("GET", "/", s.DefaultHandler)
}
2015-09-17 20:57:27 +02:00
2016-04-15 20:52:15 +02:00
// Port testing
2018-02-11 11:19:50 +01:00
if s.LookupPort != nil {
2018-03-18 22:15:51 +01:00
r.RoutePrefix("GET", "/port/", s.PortHandler)
2018-02-10 17:52:55 +01:00
}
2016-04-15 20:52:15 +02:00
2020-09-05 12:21:02 +02:00
// Profiling
if s.profile {
2020-09-11 21:16:43 +02:00
r.Route("POST", "/debug/cache/resize", s.cacheResizeHandler)
2020-09-11 20:52:35 +02:00
r.Route("GET", "/debug/cache/", s.cacheHandler)
2020-09-05 12:21:02 +02:00
r.Route("GET", "/debug/pprof/cmdline", wrapHandlerFunc(pprof.Cmdline))
r.Route("GET", "/debug/pprof/profile", wrapHandlerFunc(pprof.Profile))
r.Route("GET", "/debug/pprof/symbol", wrapHandlerFunc(pprof.Symbol))
r.Route("GET", "/debug/pprof/trace", wrapHandlerFunc(pprof.Trace))
r.RoutePrefix("GET", "/debug/pprof/", wrapHandlerFunc(pprof.Index))
}
2018-03-18 22:15:51 +01:00
return r.Handler()
2015-09-17 20:57:27 +02:00
}
2018-02-10 13:24:32 +01:00
func (s *Server) ListenAndServe(addr string) error {
return http.ListenAndServe(addr, s.Handler())
}
2018-06-15 09:29:13 +02:00
func formatCoordinate(c float64) string {
return strconv.FormatFloat(c, 'f', 6, 64)
}