HimbeerserverDE
/
multiserver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #61 from anon55555/improvements 

Simplify DB code
master
HimbeerserverDE 2021-04-01 14:43:45 +02:00 committed by GitHub
parent 16d53ef0a0 840c0fe13f
commit c872649c1e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 51 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
auth.go
View File

@ -12,8 +12,9 @@ import (
)
const (
AuthMechSRP = 0x00000002
AuthMechFirstSRP = 0x00000004
_ = 1 << iota
AuthMechSRP
AuthMechFirstSRP
)
var passPhrase []byte
@ -51,26 +52,22 @@ func initAuthDB() (*sql.DB, error) {
if err != nil {
return nil, err
}
if db == nil {
panic("DB is nil")
}
sql_table := `CREATE TABLE IF NOT EXISTS auth (
name VARCHAR(32) NOT NULL,
password VARCHAR(512) NOT NULL
);
CREATE TABLE IF NOT EXISTS privileges (
name VARCHAR(32) NOT NULL,
privileges VARCHAR(1024)
);
CREATE TABLE IF NOT EXISTS ban (
addr VARCHAR(39) NOT NULL,
name VARCHAR(32) NOT NULL
);
`
_, err = db.Exec(sql_table)
if err != nil {
if _, err := db.Exec(`
CREATE TABLE IF NOT EXISTS auth (
name VARCHAR(32) NOT NULL,
password VARCHAR(512) NOT NULL
);
CREATE TABLE IF NOT EXISTS privileges (
name VARCHAR(32) NOT NULL,
privileges VARCHAR(1024)
);
CREATE TABLE IF NOT EXISTS ban (
addr VARCHAR(39) NOT NULL,
name VARCHAR(32) NOT NULL
);
`); err != nil {
db.Close()
return nil, err
}
@ -79,68 +76,26 @@ func initAuthDB() (*sql.DB, error) {
// addAuthItem inserts an auth DB entry
func addAuthItem(db *sql.DB, name, password string) error {
sql_addAuthItem := `INSERT INTO auth (
_, err := db.Exec(`INSERT INTO auth (
name,
password
) VALUES (
?,
?
);
`
stmt, err := db.Prepare(sql_addAuthItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(name, password)
if err != nil {
return err
}
return nil
);`, name, password)
return err
}
// modAuthItem updates an auth DB entry
func modAuthItem(db *sql.DB, name, password string) error {
sql_modAuthItem := `UPDATE auth SET password = ? WHERE name = ?;`
stmt, err := db.Prepare(sql_modAuthItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(password, name)
if err != nil {
return err
}
return nil
_, err := db.Exec(`UPDATE auth SET password = ? WHERE name = ?;`, password, name)
return err
}
// readAuthItem selects and reads an auth DB entry
func readAuthItem(db *sql.DB, name string) (string, error) {
sql_readAuthItem := `SELECT password FROM auth WHERE name = ?;`
stmt, err := db.Prepare(sql_readAuthItem)
if err != nil {
return "", err
}
defer stmt.Close()
rows, err := stmt.Query(name)
if err != nil {
return "", err
}
var r string
for rows.Next() {
err = rows.Scan(&r)
}
err := db.QueryRow(`SELECT password FROM auth WHERE name = ?;`, name).Scan(&r)
return r, err
}

64
ban.go
View File

@ -16,88 +16,38 @@ var ErrInvalidAddress = errors.New("invalid ip address format")
// addBanItem inserts a ban DB entry
func addBanItem(db *sql.DB, addr, name string) error {
sql_addBanItem := `INSERT INTO ban (
_, err := db.Exec(`INSERT INTO ban (
addr,
name
) VALUES (
?,
?
);
`
stmt, err := db.Prepare(sql_addBanItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(addr, name)
if err != nil {
return err
}
return nil
);`, name)
return err
}
// readBanItem selects and reads a ban DB entry
func readBanItem(db *sql.DB, addr string) (string, error) {
sql_readBanItem := `SELECT name FROM ban WHERE addr = ?;`
stmt, err := db.Prepare(sql_readBanItem)
if err != nil {
return "", err
}
defer stmt.Close()
rows, err := stmt.Query(addr)
if err != nil {
return "", err
}
var r string
for rows.Next() {
err = rows.Scan(&r)
}
err := db.QueryRow(`SELECT name FROM ban WHERE addr = ?;`, addr).Scan(&r)
return r, err
}
// deleteBanItem deletes a ban DB entry
func deleteBanItem(db *sql.DB, name string) error {
sql_deleteBanItem := `DELETE FROM ban WHERE name = ? OR addr = ?;`
stmt, err := db.Prepare(sql_deleteBanItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(name, name)
if err != nil {
return err
}
return nil
_, err := db.Exec(`DELETE FROM ban WHERE name = ? OR addr = ?;`, name)
return err
}
// BanList returns the list of banned players and IP addresses
func BanList() (map[string]string, error) {
sql_readBanItems := `SELECT addr, name FROM ban;`
db, err := initAuthDB()
if err != nil {
return nil, err
}
defer db.Close()
stmt, err := db.Prepare(sql_readBanItems)
if err != nil {
return nil, err
}
defer stmt.Close()
rows, err := stmt.Query()
rows, err := db.Query(`SELECT addr, name FROM ban;`)
if err != nil {
return nil, err
}

50
privs.go
View File

@ -50,68 +50,26 @@ func decodePrivs(s string) map[string]bool {
// addPrivItem inserts a priv DB entry
func addPrivItem(db *sql.DB, name string) error {
sql_addPrivItem := `INSERT INTO privileges (
_, err := db.Exec(`INSERT INTO privileges (
name,
privileges
) VALUES (
?,
""
);
`
stmt, err := db.Prepare(sql_addPrivItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(name)
if err != nil {
return err
}
);`, name)
return nil
}
// modPrivItem updates a priv DB entry
func modPrivItem(db *sql.DB, name, privs string) error {
sql_modPrivItem := `UPDATE privileges SET privileges = ? WHERE name = ?;`
stmt, err := db.Prepare(sql_modPrivItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(privs, name)
if err != nil {
return err
}
_, err := db.Exec(`UPDATE privileges SET privileges = ? WHERE name = ?;`, name)
return nil
}
// readPrivItem selects and reads a priv DB entry
func readPrivItem(db *sql.DB, name string) (string, error) {
sql_readPrivItem := `SELECT privileges FROM privileges WHERE name = ?;`
stmt, err := db.Prepare(sql_readPrivItem)
if err != nil {
return "", err
}
defer stmt.Close()
rows, err := stmt.Query(name)
if err != nil {
return "", err
}
var r string
for rows.Next() {
err = rows.Scan(&r)
}
err := db.QueryRow(`SELECT privileges FROM privileges WHERE name = ?;`, name).Scan(&r)
return r, err
}

95
storage.go
View File

@ -14,90 +14,18 @@ func initStorageDB() (*sql.DB, error) {
if err != nil {
return nil, err
}
if db == nil {
panic("DB is nil")
}
sql_table := `CREATE TABLE IF NOT EXISTS storage (
if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS storage (
key VARCHAR(512) NOT NULL,
value VARCHAR(512) NOT NULL
);
`
_, err = db.Exec(sql_table)
if err != nil {
);`); err != nil {
db.Close()
return nil, err
}
return db, nil
}
func modOrAddStorageItem(db *sql.DB, key, value string) error {
deleteStorageItem(db, key)
sql_addStorageItem := `INSERT INTO storage (
key,
value
) VALUES (
?,
?
);
`
stmt, err := db.Prepare(sql_addStorageItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(key, value)
if err != nil {
return err
}
return nil
}
func readStorageItem(db *sql.DB, key string) (string, error) {
sql_readStorageItem := `SELECT value FROM storage WHERE key = ?;`
stmt, err := db.Prepare(sql_readStorageItem)
if err != nil {
return "", err
}
defer stmt.Close()
rows, err := stmt.Query(key)
if err != nil {
return "", err
}
var r string
for rows.Next() {
err = rows.Scan(&r)
}
return r, err
}
func deleteStorageItem(db *sql.DB, key string) error {
sql_deleteStorageItem := `DELETE FROM storage WHERE key = ?;`
stmt, err := db.Prepare(sql_deleteStorageItem)
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(key)
if err != nil {
return err
}
return nil
}
// SetStorageKey sets an entry in the storage database
func SetStorageKey(key, value string) error {
db, err := initStorageDB()
@ -107,10 +35,17 @@ func SetStorageKey(key, value string) error {
defer db.Close()
if value == "" {
return deleteStorageItem(db, key)
_, err = db.Exec(`DELETE FROM storage WHERE key = ?;`)
} else {
_, err = db.Exec(`REPLACE INTO storage (
key,
value
) VALUES (
?,
?
);`, key, value)
}
return modOrAddStorageItem(db, key, value)
return err
}
// StorageKey returns an entry from the storage database
@ -121,5 +56,7 @@ func StorageKey(key string) (string, error) {
}
defer db.Close()
return readStorageItem(db, key)
var r string
err := db.QueryRow(`SELECT value FROM storage WHERE key = ?;`, key).Scan(&r)
return r, err
}