External/grumble
1
0
Fork 1
mirror of https://github.com/mumble-voip/grumble.git synced 2025-12-19 21:59:59 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove global command line arguments variable, and only define command line flags from the main function.

Browse source
This commit is contained in:
Ola Bini 2020-03-26 18:40:23 +00:00
parent a6dc45193a
commit ccdbb58cb6
No known key found for this signature in database
GPG key ID: 6786A150F6A2B28F
8 changed files with 53 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

20
cmd/grumble/args.go
View file

@ -85,16 +85,20 @@ func Usage() {
}
}
var Args args
func readCommandlineArguments() args {
var a args
func init() {
flag.Usage = Usage
flag.BoolVar(&Args.ShowHelp, "help", false, "")
flag.StringVar(&Args.DataDir, "datadir", defaultDataDir(), "")
flag.StringVar(&Args.LogPath, "log", defaultLogPath(), "")
flag.BoolVar(&Args.RegenKeys, "regen-keys", false, "")
flag.BoolVar(&a.ShowHelp, "help", false, "")
flag.StringVar(&a.DataDir, "datadir", defaultDataDir(), "")
flag.StringVar(&a.LogPath, "log", defaultLogPath(), "")
flag.BoolVar(&a.RegenKeys, "regen-keys", false, "")
flag.StringVar(&Args.SQLiteDB, "import-murmurdb", "", "")
flag.BoolVar(&Args.CleanUp, "cleanup", false, "")
flag.StringVar(&a.SQLiteDB, "import-murmurdb", "", "")
flag.BoolVar(&a.CleanUp, "cleanup", false, "")
flag.Parse()
return a
}

7
cmd/grumble/freeze.go
View file

@ -52,7 +52,7 @@ func (server *Server) openFreezeLog() error {
server.freezelog = nil
}
logfn := filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10), "log.fz")
logfn := filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10), "log.fz")
err := os.Remove(logfn)
if os.IsNotExist(err) {
// fallthrough
@ -374,13 +374,13 @@ func FreezeGroup(group acl.Group) (*freezer.Group, error) {
// Once both the full server and the log file has been merged together
// in memory, a new full seralized server will be written and synced to
// disk, and the existing log file will be removed.
func NewServerFromFrozen(name string) (s *Server, err error) {
func NewServerFromFrozen(name string, dataDir string) (s *Server, err error) {
id, err := strconv.ParseInt(name, 10, 64)
if err != nil {
return nil, err
}
path := filepath.Join(Args.DataDir, "servers", name)
path := filepath.Join(dataDir, "servers", name)
mainFile := filepath.Join(path, "main.fz")
backupFile := filepath.Join(path, "backup.fz")
logFn := filepath.Join(path, "log.fz")
@ -424,6 +424,7 @@ func NewServerFromFrozen(name string) (s *Server, err error) {
if err != nil {
return nil, err
}
s.DataDir = dataDir
s.cfg = serverconf.New(cfgMap)
// Unfreeze the server's frozen bans.

4
cmd/grumble/freeze_unix.go
View file

@ -30,7 +30,7 @@ func (server *Server) freezeToFile() (err error) {
if err != nil {
return err
}
f, err := ioutil.TempFile(filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10)), ".main.fz_")
f, err := ioutil.TempFile(filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10)), ".main.fz_")
if err != nil {
return err
}
@ -50,7 +50,7 @@ func (server *Server) freezeToFile() (err error) {
if err != nil {
return err
}
err = os.Rename(f.Name(), filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10), "main.fz"))
err = os.Rename(f.Name(), filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10), "main.fz"))
if err != nil {
return err
}

6
cmd/grumble/freeze_windows.go
View file

@ -29,7 +29,7 @@ func (server *Server) freezeToFile() (err error) {
if err != nil {
return err
}
f, err := ioutil.TempFile(filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10)), ".main.fz_")
f, err := ioutil.TempFile(filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10)), ".main.fz_")
if err != nil {
return err
}
@ -51,8 +51,8 @@ func (server *Server) freezeToFile() (err error) {
}
src := f.Name()
dst := filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10), "main.fz")
backup := filepath.Join(Args.DataDir, "servers", strconv.FormatInt(server.Id, 10), "backup.fz")
dst := filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10), "main.fz")
backup := filepath.Join(server.DataDir, "servers", strconv.FormatInt(server.Id, 10), "backup.fz")
err = replacefile.ReplaceFile(dst, src, backup, replacefile.Flag(0))
// If the dst file does not exist (as in, on first launch)

6
cmd/grumble/gencert.go
View file

@ -20,7 +20,7 @@ import (
// Generate a 4096-bit RSA keypair and a Grumble auto-generated X509
// certificate. Output PEM-encoded DER representations of the resulting
// certificate and private key to certpath and keypath.
func GenerateSelfSignedCert(certpath, keypath string) (err error) {
func GenerateSelfSignedCert(certpath, keypath string, dataDir string) (err error) {
now := time.Now()
tmpl := &x509.Certificate{
SerialNumber: big.NewInt(0),
@ -56,7 +56,7 @@ func GenerateSelfSignedCert(certpath, keypath string) (err error) {
Bytes: keybuf,
}
certfn := filepath.Join(Args.DataDir, "cert.pem")
certfn := filepath.Join(dataDir, "cert.pem")
file, err := os.OpenFile(certfn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0700)
if err != nil {
return err
@ -67,7 +67,7 @@ func GenerateSelfSignedCert(certpath, keypath string) (err error) {
return err
}
keyfn := filepath.Join(Args.DataDir, "key.pem")
keyfn := filepath.Join(dataDir, "key.pem")
file, err = os.OpenFile(keyfn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0700)
if err != nil {
return err

44
cmd/grumble/grumble.go
View file

@ -5,7 +5,6 @@
package main
import (
"flag"
"fmt"
"log"
"os"
@ -22,31 +21,31 @@ var blobStore blobstore.BlobStore
func main() {
var err error
flag.Parse()
if Args.ShowHelp == true {
cmdArgs := readCommandlineArguments()
if cmdArgs.ShowHelp == true {
Usage()
return
}
// Open the data dir to check whether it exists.
dataDir, err := os.Open(Args.DataDir)
dataDir, err := os.Open(cmdArgs.DataDir)
if err != nil {
log.Fatalf("Unable to open data directory (%v): %v", Args.DataDir, err)
log.Fatalf("Unable to open data directory (%v): %v", cmdArgs.DataDir, err)
return
}
dataDir.Close()
// Set up logging
err = logtarget.Target.OpenFile(Args.LogPath)
err = logtarget.Target.OpenFile(cmdArgs.LogPath)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to open log file (%v): %v", Args.LogPath, err)
fmt.Fprintf(os.Stderr, "Unable to open log file (%v): %v", cmdArgs.LogPath, err)
return
}
log.SetPrefix("[G] ")
log.SetFlags(log.LstdFlags | log.Lmicroseconds)
log.SetOutput(&logtarget.Target)
log.Printf("Grumble")
log.Printf("Using data directory: %s", Args.DataDir)
log.Printf("Using data directory: %s", cmdArgs.DataDir)
// Open the blobstore. If the directory doesn't
// already exist, create the directory and open
@ -54,7 +53,7 @@ func main() {
// The Open method of the blobstore performs simple
// sanity checking of content of the blob directory,
// and will return an error if something's amiss.
blobDir := filepath.Join(Args.DataDir, "blob")
blobDir := filepath.Join(cmdArgs.DataDir, "blob")
err = os.Mkdir(blobDir, 0700)
if err != nil && !os.IsExist(err) {
log.Fatalf("Unable to create blob directory (%v): %v", blobDir, err)
@ -66,10 +65,10 @@ func main() {
// These are used as the default certificate of all virtual servers
// and the SSH admin console, but can be overridden using the "key"
// and "cert" arguments to Grumble.
certFn := filepath.Join(Args.DataDir, "cert.pem")
keyFn := filepath.Join(Args.DataDir, "key.pem")
certFn := filepath.Join(cmdArgs.DataDir, "cert.pem")
keyFn := filepath.Join(cmdArgs.DataDir, "key.pem")
shouldRegen := false
if Args.RegenKeys {
if cmdArgs.RegenKeys {
shouldRegen = true
} else {
// OK. Here's the idea: We check for the existence of the cert.pem
@ -100,7 +99,7 @@ func main() {
if shouldRegen {
log.Printf("Generating 4096-bit RSA keypair for self-signed certificate...")
err := GenerateSelfSignedCert(certFn, keyFn)
err := GenerateSelfSignedCert(certFn, keyFn, cmdArgs.DataDir)
if err != nil {
log.Printf("Error: %v", err)
return
@ -111,8 +110,8 @@ func main() {
}
// Should we import data from a Murmur SQLite file?
if SQLiteSupport && len(Args.SQLiteDB) > 0 {
f, err := os.Open(Args.DataDir)
if SQLiteSupport && len(cmdArgs.SQLiteDB) > 0 {
f, err := os.Open(cmdArgs.DataDir)
if err != nil {
log.Fatalf("Murmur import failed: %s", err.Error())
}
@ -123,20 +122,20 @@ func main() {
log.Fatalf("Murmur import failed: %s", err.Error())
}
if !Args.CleanUp && len(names) > 0 {
if !cmdArgs.CleanUp && len(names) > 0 {
log.Fatalf("Non-empty datadir. Refusing to import Murmur data.")
}
if Args.CleanUp {
if cmdArgs.CleanUp {
log.Print("Cleaning up existing data directory")
for _, name := range names {
if err := os.RemoveAll(filepath.Join(Args.DataDir, name)); err != nil {
if err := os.RemoveAll(filepath.Join(cmdArgs.DataDir, name)); err != nil {
log.Fatalf("Unable to cleanup file: %s", name)
}
}
}
log.Printf("Importing Murmur data from '%s'", Args.SQLiteDB)
if err = MurmurImport(Args.SQLiteDB); err != nil {
log.Printf("Importing Murmur data from '%s'", cmdArgs.SQLiteDB)
if err = MurmurImport(cmdArgs.SQLiteDB, cmdArgs.DataDir); err != nil {
log.Fatalf("Murmur import failed: %s", err.Error())
}
@ -148,7 +147,7 @@ func main() {
// Create the servers directory if it doesn't already
// exist.
serversDirPath := filepath.Join(Args.DataDir, "servers")
serversDirPath := filepath.Join(cmdArgs.DataDir, "servers")
err = os.Mkdir(serversDirPath, 0700)
if err != nil && !os.IsExist(err) {
log.Fatalf("Unable to create servers directory: %v", err)
@ -177,7 +176,7 @@ func main() {
for _, name := range names {
if matched, _ := regexp.MatchString("^[0-9]+$", name); matched {
log.Printf("Loading server %v", name)
s, err := NewServerFromFrozen(name)
s, err := NewServerFromFrozen(name, cmdArgs.DataDir)
if err != nil {
log.Fatalf("Unable to load server: %v", err.Error())
}
@ -192,6 +191,7 @@ func main() {
// If no servers were found, create the default virtual server.
if len(servers) == 0 {
s, err := NewServer(1)
s.DataDir = cmdArgs.DataDir
if err != nil {
log.Fatalf("Couldn't start server: %s", err.Error())
}

4
cmd/grumble/murmurdb.go
View file

@ -39,7 +39,7 @@ const (
const SQLiteSupport = true
// Import the structure of an existing Murmur SQLite database.
func MurmurImport(filename string) (err error) {
func MurmurImport(filename string, dataDir string) (err error) {
db, err := sql.Open("sqlite", filename)
if err != nil {
panic(err.Error())
@ -68,7 +68,7 @@ func MurmurImport(filename string) (err error) {
return err
}
err = os.Mkdir(filepath.Join(Args.DataDir, strconv.FormatInt(sid, 10)), 0750)
err = os.Mkdir(filepath.Join(dataDir, strconv.FormatInt(sid, 10)), 0750)
if err != nil {
return err
}

7
cmd/grumble/server.go
View file

@ -122,6 +122,9 @@ type Server struct {
// Logging
*log.Logger
// Other configuration
DataDir string
}
type clientLogForwarder struct {
@ -1425,8 +1428,8 @@ func (server *Server) Start() (err error) {
*/
// Wrap a TLS listener around the TCP connection
certFn := filepath.Join(Args.DataDir, "cert.pem")
keyFn := filepath.Join(Args.DataDir, "key.pem")
certFn := filepath.Join(server.DataDir, "cert.pem")
keyFn := filepath.Join(server.DataDir, "key.pem")
cert, err := tls.LoadX509KeyPair(certFn, keyFn)
if err != nil {
return err