242 lines
10 KiB
Go
242 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"log"
|
|
"strconv"
|
|
"syscall"
|
|
"os/signal"
|
|
"flag"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
GophorVersion = "1.0-beta"
|
|
)
|
|
|
|
var (
|
|
Config *ServerConfig
|
|
)
|
|
|
|
func main() {
|
|
/* Setup the entire server, getting slice of listeners in return */
|
|
listeners := setupServer()
|
|
|
|
/* Handle signals so we can _actually_ shutdowm */
|
|
signals := make(chan os.Signal)
|
|
signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
|
|
|
|
/* Start accepting connections on any supplied listeners */
|
|
for _, l := range listeners {
|
|
go func() {
|
|
Config.SysLog.Info("", "Listening on: gopher://%s:%s\n", l.Host.Name(), l.Host.RealPort())
|
|
|
|
for {
|
|
worker, err := l.Accept()
|
|
if err != nil {
|
|
Config.SysLog.Error("", "Error accepting connection: %s\n", err.Error())
|
|
continue
|
|
}
|
|
go worker.Serve()
|
|
}
|
|
}()
|
|
}
|
|
|
|
/* When OS signal received, we close-up */
|
|
sig := <-signals
|
|
Config.SysLog.Info("", "Signal received: %v. Shutting down...\n", sig)
|
|
os.Exit(0)
|
|
}
|
|
|
|
func setupServer() []*GophorListener {
|
|
/* First we setup all the flags and parse them... */
|
|
|
|
/* Base server settings */
|
|
serverRoot := flag.String("root", "/var/gopher", "Change server root directory.")
|
|
serverBindAddr := flag.String("bind-addr", "127.0.0.1", "Change server socket bind address")
|
|
serverPort := flag.Int("port", 70, "Change server bind port.")
|
|
|
|
serverFwdPort := flag.Int("fwd-port", 0, "Change port used in '$port' replacement strings (useful if you're port forwarding).")
|
|
serverHostname := flag.String("hostname", "127.0.0.1", "Change server hostname (FQDN).")
|
|
|
|
/* Logging settings */
|
|
systemLogPath := flag.String("system-log", "", "Change server system log file (blank outputs to stderr).")
|
|
accessLogPath := flag.String("access-log", "", "Change server access log file (blank outputs to stderr).")
|
|
logOutput := flag.String("log-output", "stderr", "Change server log file handling (disable|stderr|file)")
|
|
logOpts := flag.String("log-opts", "timestamp,ip", "Comma-separated list of log options (timestamp|ip)")
|
|
|
|
/* File system */
|
|
fileMonitorFreq := flag.Duration("file-monitor-freq", time.Second*60, "Change file monitor frequency.")
|
|
|
|
/* Cache settings */
|
|
cacheSize := flag.Int("cache-size", 50, "Change file cache size, measured in file count.")
|
|
cacheFileSizeMax := flag.Float64("cache-file-max", 0.5, "Change maximum file size to be cached (in megabytes).")
|
|
cacheDisabled := flag.Bool("disable-cache", false, "Disable file caching.")
|
|
|
|
/* Content settings */
|
|
pageWidth := flag.Int("page-width", 80, "Change page width used when formatting output.")
|
|
// charSet := flag.String("charset", "", "Change default output charset.")
|
|
charSet := "utf-8"
|
|
|
|
footerText := flag.String("footer", " Gophor, a Gopher server in Go.", "Change gophermap footer text (Unix new-line separated lines).")
|
|
footerSeparator := flag.Bool("no-footer-separator", false, "Disable footer line separator.")
|
|
|
|
/* Regex */
|
|
restrictedFiles := flag.String("restrict-files", "", "New-line separated list of regex statements restricting accessible files.")
|
|
fileRemaps := flag.String("file-remap", "", "New-line separated list of file remappings of format: /virtual/relative/path -> /actual/relative/path")
|
|
|
|
/* User supplied caps.txt information */
|
|
serverDescription := flag.String("description", "Gophor, a Gopher server in Go.", "Change server description in generated caps.txt.")
|
|
serverAdmin := flag.String("admin-email", "", "Change admin email in generated caps.txt.")
|
|
serverGeoloc := flag.String("geoloc", "", "Change server gelocation string in generated caps.txt.")
|
|
|
|
/* Exec settings */
|
|
disableCgi := flag.Bool("disable-cgi", false, "Disable CGI and all executable support.")
|
|
httpCompatCgi := flag.Bool("http-compat-cgi", false, "Enable HTTP CGI script compatibility (will strip HTTP headers).")
|
|
httpHeaderBuf := flag.Int("http-header-buf", 4096, "Change max CGI read count to look for and strip HTTP headers before sending raw (bytes).")
|
|
safeExecPath := flag.String("safe-path", "/usr/bin:/bin", "Set safe PATH variable to be used when executing CGI scripts, gophermaps and inline shell commands.")
|
|
maxExecRunTime := flag.Duration("max-exec-time", time.Second*3, "Change max executable CGI, gophermap and inline shell command runtime.")
|
|
|
|
/* Buffer sizes */
|
|
socketWriteBuf := flag.Int("socket-write-buf", 4096, "Change socket write buffer size (bytes).")
|
|
socketReadBuf := flag.Int("socket-read-buf", 256, "Change socket read buffer size (bytes).")
|
|
socketReadMax := flag.Int("socket-read-max", 8, "Change socket read count max (integer multiplier socket-read-buf-max)")
|
|
fileReadBuf := flag.Int("file-read-buf", 4096, "Change file read buffer size (bytes).")
|
|
|
|
/* Socket deadliens */
|
|
socketReadTimeout := flag.Duration("socket-read-timeout", time.Second*5, "Change socket read deadline (timeout).")
|
|
socketWriteTimeout := flag.Duration("socket-write-timeout", time.Second*30, "Change socket write deadline (timeout).")
|
|
|
|
/* Version string */
|
|
version := flag.Bool("version", false, "Print version information.")
|
|
|
|
/* Parse parse parse!! */
|
|
flag.Parse()
|
|
if *version {
|
|
printVersionExit()
|
|
}
|
|
|
|
/* Setup the server configuration instance and enter as much as we can right now */
|
|
Config = new(ServerConfig)
|
|
|
|
/* Set misc content settings */
|
|
Config.PageWidth = *pageWidth
|
|
|
|
/* Setup various buffer sizes */
|
|
Config.SocketWriteBufSize = *socketWriteBuf
|
|
Config.SocketReadBufSize = *socketReadBuf
|
|
Config.SocketReadMax = *socketReadBuf * *socketReadMax
|
|
Config.FileReadBufSize = *fileReadBuf
|
|
|
|
/* Setup socket deadlines */
|
|
Config.SocketReadDeadline = *socketReadTimeout
|
|
Config.SocketWriteDeadline = *socketWriteTimeout
|
|
|
|
/* Have to be set AFTER page width variable set */
|
|
Config.FooterText = formatGophermapFooter(*footerText, !*footerSeparator)
|
|
|
|
/* Setup Gophor logging system */
|
|
Config.SysLog, Config.AccLog = setupLoggers(*logOutput, *logOpts, *systemLogPath, *accessLogPath)
|
|
|
|
/* Set CGI support status */
|
|
if *disableCgi {
|
|
Config.SysLog.Info("", "CGI support disabled\n")
|
|
Config.CgiEnabled = false
|
|
} else {
|
|
/* Enable CGI */
|
|
Config.SysLog.Info("", "CGI support enabled\n")
|
|
Config.CgiEnabled = true
|
|
|
|
if *httpCompatCgi {
|
|
Config.SysLog.Info("", "Enabling HTTP CGI script compatibility\n")
|
|
executeCgi = executeCgiStripHttp
|
|
|
|
/* Specific to CGI buffer */
|
|
Config.SysLog.Info("", "Max CGI HTTP header read-ahead: %d bytes\n", *httpHeaderBuf)
|
|
Config.SkipPrefixBufSize = *httpHeaderBuf
|
|
} else {
|
|
executeCgi = executeCgiNoHttp
|
|
}
|
|
|
|
/* Set safe executable path and setup environments */
|
|
Config.SysLog.Info("", "Setting safe executable path: %s\n", *safeExecPath)
|
|
Config.Env = setupExecEnviron(*safeExecPath)
|
|
Config.CgiEnv = setupInitialCgiEnviron(*safeExecPath, charSet)
|
|
|
|
/* Set executable watchdog */
|
|
Config.SysLog.Info("", "Max executable time: %s\n", *maxExecRunTime)
|
|
Config.MaxExecRunTime = *maxExecRunTime
|
|
}
|
|
|
|
/* If running as root, get ready to drop privileges */
|
|
if syscall.Getuid() == 0 || syscall.Getgid() == 0 {
|
|
log.Fatalf("", "Gophor does not support running as root!\n")
|
|
}
|
|
|
|
/* Enter server dir */
|
|
enterServerDir(*serverRoot)
|
|
Config.SysLog.Info("", "Entered server directory: %s\n", *serverRoot)
|
|
|
|
/* Setup listeners */
|
|
listeners := make([]*GophorListener, 0)
|
|
|
|
/* If requested, setup unencrypted listener */
|
|
if *serverPort != 0 {
|
|
/* If no forward port set, just use regular */
|
|
if *serverFwdPort == 0 {
|
|
*serverFwdPort = *serverPort
|
|
}
|
|
|
|
l, err := BeginGophorListen(*serverBindAddr, *serverHostname, strconv.Itoa(*serverPort), strconv.Itoa(*serverFwdPort), *serverRoot)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up (unencrypted) listener: %s\n", err.Error())
|
|
}
|
|
listeners = append(listeners, l)
|
|
} else {
|
|
log.Fatalf("No valid port to listen on\n")
|
|
}
|
|
|
|
/* Setup file cache */
|
|
Config.FileSystem = new(FileSystem)
|
|
|
|
/* Check if cache requested disabled */
|
|
if !*cacheDisabled {
|
|
/* Init file cache */
|
|
Config.FileSystem.Init(*cacheSize, *cacheFileSizeMax)
|
|
|
|
/* Before file monitor or any kind of new goroutines started,
|
|
* check if we need to cache generated policy files
|
|
*/
|
|
cachePolicyFiles(*serverRoot, *serverDescription, *serverAdmin, *serverGeoloc)
|
|
|
|
/* Start file cache freshness checker */
|
|
startFileMonitor(*fileMonitorFreq)
|
|
Config.SysLog.Info("", "File caching enabled with: maxcount=%d maxsize=%.3fMB checkfreq=%s\n", *cacheSize, *cacheFileSizeMax, *fileMonitorFreq)
|
|
} else {
|
|
/* File caching disabled, init with zero max size so nothing gets cached */
|
|
Config.FileSystem.Init(2, 0)
|
|
Config.SysLog.Info("", "File caching disabled\n")
|
|
|
|
/* Safe to cache policy files now */
|
|
cachePolicyFiles(*serverRoot, *serverDescription, *serverAdmin, *serverGeoloc)
|
|
}
|
|
|
|
/* Setup file restrictions and remappings */
|
|
Config.FileSystem.Restricted = compileUserRestrictedRegex(*restrictedFiles)
|
|
Config.FileSystem.Remaps = compileUserRemapRegex(*fileRemaps)
|
|
|
|
/* Precompile some helpful regex */
|
|
Config.RgxGophermap = compileGophermapCheckRegex()
|
|
Config.RgxCgiBin = compileCgiBinCheckRegex()
|
|
|
|
/* Return the created listeners slice :) */
|
|
return listeners
|
|
}
|
|
|
|
func enterServerDir(path string) {
|
|
err := syscall.Chdir(path)
|
|
if err != nil {
|
|
log.Fatalf("Error changing dir to server root %s: %s\n", path, err.Error())
|
|
}
|
|
}
|