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

Merge ccdbb58cb6 into f4d41de536

Browse source
This commit is contained in:
Ola Bini 2020-04-11 19:06:21 -07:00 • committed by GitHub
commit ad88c9a4e1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
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 {
@ -1432,8 +1435,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