send-over-http

send_over_http.go (3135B)

---

 package sendoverhttp
 
 import (
 	"errors"
 	"io/fs"
 	"log"
 	"net"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
 )
 
 // Config contains the configuration parameters for the service.
 type Config struct {
 	// FilePath is the file to serve.
 	FilePath string
 	// ListenAddress is the network address to listen for connections.
 	ListenAddress string
 	// Network type to listen on.
 	Network string
 }
 
 // Source a single listening address to listen on.
 func getListenAddress(config Config) (string, error) {
 	switch config.Network {
 	case "tcp", "tcp4", "tcp6":
 	default:
 		return config.ListenAddress, nil
 	}
 
 	addr, port, err := net.SplitHostPort(config.ListenAddress)
 	if err != nil {
 		addr = config.ListenAddress
 		port = "0"
 	}
 
 	if addr != "" {
 		ip := net.ParseIP(addr)
 		if ip == nil {
 			return config.ListenAddress, nil
 		}
 		if !ip.IsUnspecified() {
 			return config.ListenAddress, nil
 		}
 	}
 
 	ips, err := net.InterfaceAddrs()
 	if err != nil {
 		return "", err
 	}
 
 	// Valid fallback if no other interfaces available
 	var loopback *net.IP = nil
 
 	for _, addr := range ips {
 		ipNet, ok := addr.(*net.IPNet)
 		if !ok {
 			continue
 		}
 		if config.Network == "tcp6" && ipNet.IP.To4() != nil {
 			continue
 		}
 		if ipNet.IP.IsLoopback() {
 			loopback = &ipNet.IP
 			continue
 		}
 		return net.JoinHostPort(ipNet.IP.String(), port), nil
 	}
 
 	if loopback != nil {
 		return net.JoinHostPort((*loopback).String(), port), nil
 	}
 	return "", errors.New("no valid network address could be found")
 }
 
 type Server struct {
 	config Config
 
 	closeCh chan struct{}
 	mr      *MultiRunner
 }
 
 type SingleFileDir string
 
 func (s SingleFileDir) Open(name string) (http.File, error) {
 	if name == "index.html" {
 		return nil, fs.ErrNotExist
 	}
 
 	fp := string(s)
 	stat, err := os.Stat(fp)
 	if err != nil {
 		return nil, err
 	}
 	if stat.IsDir() {
 		return http.Dir(fp).Open(name)
 	}
 
 	switch name {
 	case "/":
 		return nil, os.ErrNotExist
 	case "/" + filepath.Base(fp):
 		return os.Open(fp)
 	default:
 		return nil, os.ErrNotExist
 
 	}
 }
 
 func NewServer(config Config) *Server {
 	return &Server{
 		config: config,
 
 		closeCh: make(chan struct{}),
 		mr:      NewMultiRunner(),
 	}
 }
 
 func (s *Server) Start() error {
 	listenAddr, err := getListenAddress(s.config)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	l, err := net.Listen(s.config.Network, listenAddr)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	u := url.URL{
 		Scheme: "http",
 		Host:   l.Addr().String(),
 	}
 	if stat, _ := os.Stat(s.config.FilePath); !stat.IsDir() {
 		u.Path = filepath.Base(s.config.FilePath)
 	}
 
 	qrCodeShower := NewTerminalQRShower(u.String())
 	go s.mr.Run(qrCodeShower)
 
 	var d http.FileSystem = http.Dir(s.config.FilePath)
 	if stat, _ := os.Stat(s.config.FilePath); !stat.IsDir() {
 		// Show user the name of the file
 		d = SingleFileDir(s.config.FilePath)
 	}
 	httpSrv := &http.Server{
 		Handler: http.FileServer(d),
 	}
 
 	httpRunner := NewRunner()
 	httpRunner.OnStart = func() error {
 		return httpSrv.Serve(l)
 	}
 	httpRunner.OnStop = func() {
 		_ = httpSrv.Close()
 	}
 	go s.mr.Run(httpRunner)
 
 	<-s.closeCh
 	close(s.closeCh)
 	return nil
 }
 
 func (s *Server) Stop() {
 	s.mr.Stop()
 	return
 }