local-ip.sh/http/server.go

151 lines
4.2 KiB
Go
Raw Normal View History

2023-12-12 22:05:57 +00:00
package http
import (
"context"
2024-07-26 10:16:23 +00:00
"fmt"
"net"
2023-12-12 22:05:57 +00:00
"net/http"
2024-07-09 23:09:18 +00:00
"os"
2024-07-26 10:16:23 +00:00
"strconv"
2024-07-09 23:09:18 +00:00
"strings"
"time"
2024-07-19 00:24:11 +00:00
"local-ip.sh/utils"
2023-12-12 22:05:57 +00:00
)
func newHttpMux() *http.ServeMux {
mux := http.NewServeMux()
mux.HandleFunc("GET /server.key", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/octet-stream")
2024-07-20 00:43:52 +00:00
http.ServeFile(w, r, "./.lego/certs/wildcard/server.key")
2023-12-12 22:05:57 +00:00
})
mux.HandleFunc("GET /server.pem", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/x-x509-ca-cert")
2024-07-20 00:43:52 +00:00
http.ServeFile(w, r, "./.lego/certs/wildcard/server.pem")
2024-07-09 23:09:18 +00:00
})
mux.HandleFunc("GET /og.png", func(w http.ResponseWriter, r *http.Request) {
2024-07-09 23:09:18 +00:00
w.Header().Set("Content-Type", "image/png; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=3600")
http.ServeFile(w, r, "./http/static/og.png")
})
mux.HandleFunc("GET /favicon.ico", func(w http.ResponseWriter, r *http.Request) {
2024-07-09 23:09:18 +00:00
w.Header().Set("Content-Type", "image/x-icon; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=3600")
http.ServeFile(w, r, "./http/static/favicon.ico")
2023-12-12 22:05:57 +00:00
})
mux.HandleFunc("GET /styles.css", func(w http.ResponseWriter, r *http.Request) {
2024-07-09 23:09:18 +00:00
w.Header().Set("Content-Type", "text/css; charset=utf-8")
http.ServeFile(w, r, "./http/static/styles.css")
})
mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.Error(w, "Not Found", http.StatusNotFound)
return
}
2024-07-09 23:09:18 +00:00
w.Header().Set("Content-Type", "text/html; charset=utf-8")
http.ServeFile(w, r, "./http/static/index.html")
})
return mux
}
2024-07-19 00:24:11 +00:00
func serveHttp() *http.Server {
2024-07-26 10:16:23 +00:00
config := utils.GetConfig()
httpServer := &http.Server{
Addr: fmt.Sprintf(":%d", config.HttpPort),
Handler: newHttpMux(),
}
2024-07-26 10:16:23 +00:00
utils.Logger.Info().Str("http_address", httpServer.Addr).Msg("Starting up HTTP server")
go func() {
err := httpServer.ListenAndServe()
if err != http.ErrServerClosed {
utils.Logger.Fatal().Err(err).Msg("Unexpected error received from HTTP server")
}
}()
return httpServer
2024-07-09 23:09:18 +00:00
}
func waitForCertificate(ready chan bool) {
2024-07-09 23:09:18 +00:00
for {
2024-07-20 00:43:52 +00:00
_, err := os.Stat("./.lego/certs/root/output.json")
2024-07-09 23:09:18 +00:00
if err != nil {
if strings.Contains(err.Error(), "no such file or directory") {
time.Sleep(1 * time.Second)
continue
}
2024-07-20 00:43:52 +00:00
utils.Logger.Fatal().Err(err).Msg("Unexpected error while looking for ./.lego/certs/root/output.json")
2024-07-09 23:09:18 +00:00
}
break
}
ready <- true
}
func killServer(httpServer *http.Server) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err := httpServer.Shutdown(ctx)
if err != nil {
utils.Logger.Fatal().Err(err).Msg("Unexpected error when shutting down HTTP server")
}
utils.Logger.Debug().Msg("HTTP server shut down correctly")
}
func redirectHttpToHttps() {
2024-07-26 10:16:23 +00:00
config := utils.GetConfig()
httpServer := &http.Server{
2024-07-26 10:16:23 +00:00
Addr: fmt.Sprintf(":%d", config.HttpPort),
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
url := r.URL
2024-07-26 10:16:23 +00:00
host := r.Host
// Strip the port from the host if present
if strings.Contains(host, ":") {
hostWithoutPort, _, err := net.SplitHostPort(host)
if err != nil {
utils.Logger.Error().Err(err).Msg("Failed to split host and port")
} else {
host = hostWithoutPort
}
}
// Add the HTTPS port only if it's not 443
if config.HttpsPort != 443 {
host = net.JoinHostPort(host, strconv.FormatUint(uint64(config.HttpsPort), 10))
}
url.Host = r.Host
url.Scheme = "https"
http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
}),
}
2024-07-26 10:16:23 +00:00
utils.Logger.Info().Str("http_address", httpServer.Addr).Msg("Redirecting HTTP traffic to HTTPS")
go httpServer.ListenAndServe()
}
func serveHttps() {
2024-07-26 10:16:23 +00:00
config := utils.GetConfig()
mux := newHttpMux()
httpsServer := &http.Server{
Addr: fmt.Sprintf(":%d", config.HttpsPort),
Handler: mux,
}
2024-07-26 10:16:23 +00:00
utils.Logger.Info().Str("https_address", httpsServer.Addr).Msg("Starting up HTTPS server")
2024-07-20 00:43:52 +00:00
go httpsServer.ListenAndServeTLS("./.lego/certs/root/server.pem", "./.lego/certs/root/server.key")
}
func ServeHttp() {
httpServer := serveHttp()
ready := make(chan bool, 1)
go waitForCertificate(ready)
<-ready
killServer(httpServer)
serveHttps()
redirectHttpToHttps()
2023-12-12 22:05:57 +00:00
}