initial import

internal/config/.gitignore

@@ -0,0 +1,3 @@
+*~
+path.go
+user.go

internal/config/config.go

@@ -0,0 +1,105 @@
+package config
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/go-yaml/yaml"
+)
+
+const (
+	defaultPort     int = 9501
+	defaultHostname     = "localhost"
+)
+
+var (
+	defaultBuild = "NODATE"
+)
+
+type ServiceConfig struct {
+	PortNum int `json:"port" yaml:"port"`
+}
+
+type Config struct {
+	Service  ServiceConfig `json:"service"   yaml:"service"`
+	Hostname string        `json:"hostname"  yaml:"hostname"`
+	Debug    bool          `json:"debug"     yaml:"debug"`
+	Build    string        `json:"build"     yaml:"build"`
+	LogPath  string        `json:"logfile"   yaml:"logfile"`
+	RunPath  string        `json:"runfile"   yaml:"runfile"`
+	DataPath string        `json:"datadir"   yaml:"datadir"`
+	Daemon   bool          `json:"daemon"    yaml:"daemon"`
+}
+
+func NewConfig() *Config {
+	conf := &Config{
+		Service: ServiceConfig{
+			PortNum: defaultPort,
+		},
+		Debug:    false,
+		Hostname: defaultHostname,
+		Build:    defaultBuild,
+		DataPath: datadirPath,
+	}
+
+	exeName := filepath.Base(os.Args[0])
+	conf.LogPath = filepath.Join(logdirPath, fmt.Sprintf("%s.log", exeName))
+	conf.RunPath = filepath.Join(rundirPath, fmt.Sprintf("%s.pid", exeName))
+	return conf
+}
+
+func (conf *Config) ReadFile() error {
+	var err error
+	exeName := filepath.Base(os.Args[0])
+	configPath := filepath.Join(confdirPath, fmt.Sprintf("%s.yaml", exeName))
+	confBytes, err := os.ReadFile(configPath)
+	if err != nil {
+		return err
+	}
+	err = yaml.Unmarshal(confBytes, conf)
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (conf *Config) ReadEnv() error {
+	var err error
+	return err
+}
+
+func (conf *Config) ReadOpts() error {
+	var err error
+
+	exeName := filepath.Base(os.Args[0])
+
+	flag.IntVar(&conf.Service.PortNum, "port", conf.Service.PortNum, "listen port")
+	flag.BoolVar(&conf.Daemon, "daemon", conf.Daemon, "run as daemon")
+	flag.BoolVar(&conf.Debug, "debug", conf.Debug, "on debug mode")
+
+	help := func() {
+		fmt.Println("")
+		fmt.Printf("Usage: %s [option]\n", exeName)
+		fmt.Println("")
+		fmt.Println("Options:")
+		flag.PrintDefaults()
+		fmt.Println("")
+	}
+	flag.Usage = help
+	flag.Parse()
+
+	return err
+}
+
+func (conf *Config) Yaml() (string, error) {
+	var err error
+	var res string
+	yamlBytes, err := yaml.Marshal(conf)
+	if err != nil {
+		return res, err
+	}
+	res = string(yamlBytes)
+	return res, err
+}

internal/config/path.go.in

@@ -0,0 +1,10 @@
+package config
+
+
+const (
+    confdirPath = "@srv_confdir@"
+    rundirPath = "@srv_rundir@"
+    logdirPath = "@srv_logdir@"
+    datadirPath = "@srv_datadir@"
+)
+

internal/handler/handler.go

@@ -0,0 +1,56 @@
+package handler
+
+import (
+	"net/http"
+	"os"
+	"path/filepath"
+        "strings"
+
+	"filer/pkg/logger"
+
+	"github.com/gin-gonic/gin"
+)
+
+type HandlerConfig struct {
+	Datadir string
+}
+
+type Handler struct {
+	log     *logger.Logger
+	datadir string
+}
+
+func NewHandler(conf *HandlerConfig) (*Handler, error) {
+	var err error
+	hand := &Handler{
+		log: logger.NewLogger("handler"),
+	}
+	return hand, err
+}
+
+func (hand *Handler) GetFile(gctx *gin.Context) {
+	filePath := gctx.FullPath()
+	localFilePath := filepath.Join(hand.datadir, filePath)
+
+	if strings.Contains(localFilePath, "/../") {
+		gctx.Status(http.StatusBadRequest)
+                return
+	}
+	if len(filePath) > 0 && fileExists(localFilePath) {
+		gctx.FileAttachment(localFilePath, filepath.Base(filePath))
+		return
+	} else {
+		gctx.Status(http.StatusNotFound)
+		return
+	}
+}
+
+func fileExists(name string) bool {
+	fi, err := os.Stat(name)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false
+		}
+	}
+	return !fi.IsDir()
+}

internal/server/server.go

@@ -0,0 +1,236 @@
+package server
+
+import (
+	"os"
+	"os/signal"
+	"os/user"
+	"path/filepath"
+	"strconv"
+	"syscall"
+
+	"filer/internal/handler"
+	"filer/internal/config"
+	"filer/internal/service"
+	"filer/pkg/auxtool/aux509"
+	"filer/pkg/logger"
+)
+
+type Server struct {
+	conf       *config.Config
+	svc        *service.Service
+	hand     *handler.Handler
+	log        *logger.Logger
+	x509cert   []byte
+	x509key    []byte
+	x509caCert []byte
+	x509caKey  []byte
+}
+
+func NewServer() (*Server, error) {
+	var err error
+	srv := &Server{}
+	srv.log = logger.NewLogger("server")
+	return srv, err
+}
+
+func (srv *Server) Service() *service.Service {
+	return srv.svc
+}
+
+func (srv *Server) Configure() error {
+	var err error
+	srv.conf = config.NewConfig()
+
+	err = srv.conf.ReadFile()
+	if err != nil {
+		//return err
+	}
+	err = srv.conf.ReadEnv()
+	if err != nil {
+		return err
+	}
+	err = srv.conf.ReadOpts()
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (srv *Server) Build() error {
+	var err error
+	srv.log.Infof("Build server")
+
+	confData, err := srv.conf.Yaml()
+	if err != nil {
+		return err
+	}
+	srv.log.Infof("Current configuration is:\n%s\n", confData)
+
+	// Create X509 certs
+	srv.x509caCert, srv.x509caKey, err = aux509.CreateX509CACert(srv.conf.Hostname)
+	if err != nil {
+		return err
+	}
+	srv.x509cert, srv.x509key, err = aux509.CreateX509Cert(srv.conf.Hostname, srv.x509caKey)
+	if err != nil {
+		return err
+	}
+	handlerConfig := &handler.HandlerConfig{
+                Datadir: srv.conf.DataPath,
+	}
+	srv.hand, err = handler.NewHandler(handlerConfig)
+	if err != nil {
+		return err
+	}
+	// Create service
+	serviceConfig := &service.ServiceConfig{
+		PortNum:  srv.conf.Service.PortNum,
+		Hostname: srv.conf.Hostname,
+		Handler:  srv.hand,
+		X509Cert: srv.x509cert,
+		X509Key:  srv.x509key,
+	}
+	srv.svc, err = service.NewService(serviceConfig)
+	if err != nil {
+		return err
+	}
+	err = srv.svc.Build()
+	if err != nil {
+		return err
+	}
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (srv *Server) Run() error {
+	var err error
+
+	currUser, err := user.Current()
+	if err != nil {
+		return err
+	}
+	srv.log.Infof("Running server as user %s", currUser.Username)
+
+	sigs := make(chan os.Signal, 1)
+	svcDone := make(chan error, 1)
+
+	// Run service
+	startService := func(svc *service.Service, done chan error) {
+		err = svc.Run()
+		if err != nil {
+			srv.log.Errorf("Service error: %v", err)
+			done <- err
+		}
+	}
+	go startService(srv.svc, svcDone)
+
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	var signal os.Signal
+
+	select {
+	case signal = <-sigs:
+		srv.log.Infof("Services stopped by signal: %v", signal)
+		srv.svc.Stop()
+	case err = <-svcDone:
+		srv.log.Infof("Service stopped by service error: %v", err)
+		srv.svc.Stop()
+	}
+	return err
+}
+
+func (srv *Server) PseudoFork() error {
+	const successExit int = 0
+	var keyEnv string = "IMX0LTSELMRF8K"
+	var err error
+
+	_, isChild := os.LookupEnv(keyEnv)
+	switch {
+	case !isChild:
+		os.Setenv(keyEnv, "TRUE")
+
+		procAttr := syscall.ProcAttr{}
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+		var sysFiles = make([]uintptr, 3)
+		sysFiles[0] = uintptr(syscall.Stdin)
+		sysFiles[1] = uintptr(syscall.Stdout)
+		sysFiles[2] = uintptr(syscall.Stderr)
+
+		procAttr.Files = sysFiles
+		procAttr.Env = os.Environ()
+		procAttr.Dir = cwd
+
+		_, err = syscall.ForkExec(os.Args[0], os.Args, &procAttr)
+		if err != nil {
+			return err
+		}
+		os.Exit(successExit)
+	case isChild:
+		_, err = syscall.Setsid()
+		if err != nil {
+			return err
+		}
+	}
+	os.Unsetenv(keyEnv)
+	return err
+}
+
+func (srv *Server) Daemonize() error {
+	var err error
+	if srv.conf.Daemon {
+		// Restart process process
+		err = srv.PseudoFork()
+		if err != nil {
+			return err
+		}
+
+		// Redirect stdin
+		nullFile, err := os.OpenFile("/dev/null", os.O_RDWR, 0)
+		if err != nil {
+			return err
+		}
+		err = syscall.Dup2(int(nullFile.Fd()), int(os.Stdin.Fd()))
+		if err != nil {
+			return err
+		}
+		// Redirect stderr and stout
+		logdir := filepath.Dir(srv.conf.LogPath)
+		err = os.MkdirAll(logdir, 0750)
+		if err != nil {
+			return err
+		}
+		logFile, err := os.OpenFile(srv.conf.LogPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0640)
+		if err != nil {
+			return err
+		}
+		err = syscall.Dup2(int(logFile.Fd()), int(os.Stdout.Fd()))
+		if err != nil {
+			return err
+		}
+		err = syscall.Dup2(int(logFile.Fd()), int(os.Stderr.Fd()))
+		if err != nil {
+			return err
+		}
+		// Write process ID
+		rundir := filepath.Dir(srv.conf.RunPath)
+		err = os.MkdirAll(rundir, 0750)
+		if err != nil {
+			return err
+		}
+		pidFile, err := os.OpenFile(srv.conf.RunPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
+		if err != nil {
+			return err
+		}
+		defer pidFile.Close()
+		currPid := os.Getpid()
+		_, err = pidFile.WriteString(strconv.Itoa(currPid))
+		if err != nil {
+			return err
+		}
+	}
+	return err
+}

internal/service/service.go

@@ -0,0 +1,120 @@
+package service
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net/http"
+	"time"
+
+	"filer/internal/handler"
+	"filer/pkg/auxtool/auxgin"
+	"filer/pkg/logger"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	httpTimeout = 360
+)
+
+type ServiceConfig struct {
+	Handler  *handler.Handler
+	PortNum  int
+	Hostname string
+	X509Cert []byte
+	X509Key  []byte
+}
+
+type Service struct {
+	hand   *handler.Handler
+	hsrv   *http.Server
+	log    *logger.Logger
+	engine *gin.Engine
+
+	portnum  int
+	hostname string
+	x509Cert []byte
+	x509Key  []byte
+}
+
+func NewService(conf *ServiceConfig) (*Service, error) {
+	var err error
+	svc := &Service{
+		hand:     conf.Handler,
+		portnum:  conf.PortNum,
+		hostname: conf.Hostname,
+		x509Cert: conf.X509Cert,
+		x509Key:  conf.X509Key,
+	}
+	svc.log = logger.NewLogger("service")
+	return svc, err
+}
+
+func (svc *Service) Build() error {
+	var err error
+	svc.log.Debugf("Build service")
+
+	gin.SetMode(gin.ReleaseMode)
+	gin.DisableConsoleColor()
+
+	svc.engine = gin.New()
+	svc.engine.Use(gin.Recovery())
+	svc.engine.Use(auxgin.CorsMiddleware())
+	svc.engine.Use(auxgin.LogMiddleware())
+
+        svc.engine.GET("/*any", svc.hand.GetFile)
+
+	noRouteFunc := func(gctx *gin.Context) {
+		gctx.Status(http.StatusNotFound)
+                return
+	}
+	svc.engine.NoRoute(noRouteFunc)
+
+	tlsCert, err := tls.X509KeyPair(svc.x509Cert, svc.x509Key)
+	if err != nil {
+		return err
+	}
+	tlsConfig := tls.Config{
+		Certificates:       []tls.Certificate{tlsCert},
+		ClientAuth:         tls.NoClientCert,
+		InsecureSkipVerify: true,
+	}
+	listenAddr := fmt.Sprintf(":%d", svc.portnum)
+	svc.hsrv = &http.Server{
+		Addr:      listenAddr,
+		Handler:   svc.engine,
+		TLSConfig: &tlsConfig,
+	}
+	return err
+}
+
+func (svc *Service) Router() *gin.Engine {
+	return svc.engine
+}
+
+func (svc *Service) Handler() *handler.Handler {
+	return svc.hand
+}
+
+func (svc *Service) Run() error {
+	var err error
+	for _, route := range svc.engine.Routes() {
+		svc.log.Debugf("The route is registered: %s %s", route.Method, route.Path)
+	}
+	svc.log.Infof("Service listening at %d port", svc.portnum)
+	err = svc.hsrv.ListenAndServeTLS("", "")
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (svc *Service) Stop() {
+	svc.log.Infof("Stopping service")
+	if svc.hsrv != nil {
+		downWaiting := 5 * time.Second
+		ctx, _ := context.WithTimeout(context.Background(), downWaiting)
+		svc.hsrv.Shutdown(ctx)
+	}
+}