change to use logging instead of print to stdout

controllers/auth.go

@@ -1,8 +1,8 @@
 package controllers
 
 import (
-	"fmt"
 	"html"
+	"log"
 	"net/http"
 	"strings"
 
@@ -39,7 +39,7 @@ func Register(c *gin.Context) {
 
 	// Default to regular user role if not specified
 	if input.RoleId == 0 {
-		fmt.Printf("Register no role specified, defaulting to RoleId of 2.\n")
+		log.Printf("Register no role specified, defaulting to RoleId of 2.\n")
 		u.RoleId = 2
 	} else {
 		u.RoleId = input.RoleId
@@ -50,9 +50,9 @@ func Register(c *gin.Context) {
 
 	// Check if user already exists
 	testUser, _ := models.GetUserByName(u.UserName)
-	fmt.Printf("Register checking if user already exists : '%v'\n", testUser)
+	log.Printf("Register checking if user already exists : '%v'\n", testUser)
 	if (models.User{} == testUser) {
-		fmt.Printf("Register confirmed no existing username\n")
+		log.Printf("Register confirmed no existing username\n")
 	} else {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "Attempt to register conflicting username"})
 		return
@@ -64,7 +64,7 @@ func Register(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"Error hashing password": err.Error()})
 		return
 	} else {
-		fmt.Printf("Register generated hashed password value '%s' from '%s'\n", string(hashedPassword), input.Password)
+		log.Printf("Register generated hashed password value '%s' from '%s'\n", string(hashedPassword), input.Password)
 	}
 	u.Password = string(hashedPassword)
 
@@ -92,7 +92,7 @@ func Login(c *gin.Context) {
 	u.UserName = input.Username
 	u.Password = input.Password
 
-	fmt.Printf("Login checking username '%s' and password '%s'\n", u.UserName, u.Password)
+	log.Printf("Login checking username '%s' and password '%s'\n", u.UserName, u.Password)
 
 	token, err := models.LoginCheck(u.UserName, u.Password)
 

controllers/retrieve_secrets.go

@@ -3,7 +3,7 @@ package controllers
 import (
 	"ccsecrets/models"
 	"ccsecrets/utils/token"
-	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -22,7 +22,7 @@ func RetrieveSecret(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-	fmt.Printf("RetrieveSecret received JSON input '%v'\n", input)
+	log.Printf("RetrieveSecret received JSON input '%v'\n", input)
 
 	// Get the user and role id of the requestor
 	user_id, err := token.ExtractTokenID(c)
@@ -72,7 +72,7 @@ func RetrieveMultpleSecrets(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-	fmt.Printf("StoreSecret received JSON input '%v'\n", input)
+	log.Printf("StoreSecret received JSON input '%v'\n", input)
 
 	// Get the user and role id of the requestor
 	user_id, err := token.ExtractTokenID(c)

controllers/store_secrets.go

@@ -3,7 +3,7 @@ package controllers
 import (
 	"ccsecrets/models"
 	"errors"
-	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -27,7 +27,7 @@ func StoreSecret(c *gin.Context) {
 		return
 	}
 
-	fmt.Printf("StoreSecret received JSON input '%v'\n", input)
+	log.Printf("StoreSecret received JSON input '%v'\n", input)
 
 	// Populate fields
 	s := models.Secret{}
@@ -55,7 +55,7 @@ func StoreSecret(c *gin.Context) {
 	}
 
 	if len(checkExists) > 0 {
-		fmt.Printf("StoreSecret not storing secret with '%d' already matching secrets.\n", len(checkExists))
+		log.Printf("StoreSecret not storing secret with '%d' already matching secrets.\n", len(checkExists))
 		c.JSON(http.StatusBadRequest, gin.H{"error": "StoreSecret attempting to store secret already defined. API calls for update/delete don't yet exist"})
 		return
 	}
@@ -86,7 +86,7 @@ func UpdateSecret(c *gin.Context) {
 		return
 	}
 
-	fmt.Printf("UpdateSecret received JSON input '%v'\n", input)
+	log.Printf("UpdateSecret received JSON input '%v'\n", input)
 
 	// Get the user and role id of the requestor
 	u, err := models.GetUserRoleFromToken(c)

main.go

@@ -35,6 +35,7 @@ func main() {
 		fmt.Println("Unable to write logfile", err)
 		os.Exit(1)
 	}
+	log.SetOutput(logfileWriter)
 
 	// Initiate connection to sqlite and make sure our schema is up to date
 	models.ConnectDatabase()
@@ -88,7 +89,7 @@ func main() {
 		bindIP = "8443"
 	}
 	bindAddress := fmt.Sprint(bindIP, ":", bindPort)
-	fmt.Printf("Will listen on address 'https://%s'\n", bindAddress)
+	log.Printf("Will listen on address 'https://%s'\n", bindAddress)
 
 	// Get file names for TLS cert/key
 	tlsCertFilename := os.Getenv("TLS_CERT_FILE")
@@ -107,7 +108,7 @@ func main() {
 
 	// Generate certificate if required
 	if !(utils.FileExists(tlsCertFilename) && utils.FileExists(tlsKeyFilename)) {
-		fmt.Printf("Specified TLS certificate (%s) or private key (%s) do not exist.\n", tlsCertFilename, tlsKeyFilename)
+		log.Printf("Specified TLS certificate (%s) or private key (%s) do not exist.\n", tlsCertFilename, tlsKeyFilename)
 		utils.GenerateCerts(tlsCertFilename, tlsKeyFilename)
 	}
 

middlewares/middlewares.go

@@ -1,7 +1,7 @@
 package middlewares
 
 import (
-	"fmt"
+	"log"
 	"net/http"
 
 	"ccsecrets/models"
@@ -50,7 +50,7 @@ func JwtAuthAdminMiddleware() gin.HandlerFunc {
 			c.Abort()
 			return
 		}
-		fmt.Printf("JwtAuthAdminMiddleware retrieved UserRole object '%v'\n", ur)
+		log.Printf("JwtAuthAdminMiddleware retrieved UserRole object '%v'\n", ur)
 
 		if !ur.Admin {
 			c.String(http.StatusUnauthorized, "User role is Non-Admin")

models/role.go

@@ -1,6 +1,6 @@
 package models
 
-import "fmt"
+import "log"
 
 type Role struct {
 	RoleId   int    `db:"RoleId"`
@@ -16,7 +16,7 @@ func QueryRoles() ([]Role, error) {
 	rows, err := db.Queryx("SELECT * FROM roles")
 
 	if err != nil {
-		fmt.Printf("QueryRoles error executing sql record : '%s'\n", err)
+		log.Printf("QueryRoles error executing sql record : '%s'\n", err)
 		return results, err
 	} else {
 		// parse all the results into a slice
@@ -24,13 +24,13 @@ func QueryRoles() ([]Role, error) {
 			var r Role
 			err = rows.StructScan(&r)
 			if err != nil {
-				fmt.Printf("QueryRoles error parsing sql record : '%s'\n", err)
+				log.Printf("QueryRoles error parsing sql record : '%s'\n", err)
 				return results, err
 			}
 			results = append(results, r)
 
 		}
-		fmt.Printf("QueryRoles retrieved '%d' results\n", len(results))
+		log.Printf("QueryRoles retrieved '%d' results\n", len(results))
 	}
 
 	return results, nil

models/secret.go

@@ -6,8 +6,8 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"errors"
-	"fmt"
 	"io"
+	"log"
 	"os"
 
 	"github.com/jmoiron/sqlx"
@@ -29,16 +29,16 @@ func (s *Secret) SaveSecret() (*Secret, error) {
 
 	var err error
 
-	fmt.Printf("SaveSecret storing values '%v'\n", s)
+	log.Printf("SaveSecret storing values '%v'\n", s)
 	result, err := db.NamedExec((`INSERT INTO secrets (RoleId, DeviceName, DeviceCategory, UserName, Secret) VALUES (:RoleId, :DeviceName, :DeviceCategory, :UserName, :Secret)`), s)
 
 	if err != nil {
-		fmt.Printf("StoreSecret error executing sql record : '%s'\n", err)
+		log.Printf("StoreSecret error executing sql record : '%s'\n", err)
 		return s, err
 	} else {
 		affected, _ := result.RowsAffected()
 		id, _ := result.LastInsertId()
-		fmt.Printf("StoreSecret insert returned result id '%d' affecting %d row(s).\n", id, affected)
+		log.Printf("StoreSecret insert returned result id '%d' affecting %d row(s).\n", id, affected)
 	}
 
 	return s, nil
@@ -50,7 +50,7 @@ func GetSecrets(s *Secret) ([]Secret, error) {
 	var rows *sqlx.Rows
 	var secretResults []Secret
 
-	fmt.Printf("GetSecret querying values '%v'\n", s)
+	log.Printf("GetSecret querying values '%v'\n", s)
 
 	// Determine whether to query for a specific device or a category of devices
 	// Prefer querying device name than category
@@ -61,13 +61,13 @@ func GetSecrets(s *Secret) ([]Secret, error) {
 	} else if s.DeviceCategory != "" {
 		rows, err = db.Queryx("SELECT * FROM secrets WHERE DeviceCategory LIKE ? AND RoleId = ?", s.DeviceCategory, s.RoleId)
 	} else {
-		fmt.Printf("GetSecret no valid search options specified\n")
+		log.Printf("GetSecret no valid search options specified\n")
 		err = errors.New("no valid search options specified")
 		return secretResults, err
 	}
 
 	if err != nil {
-		fmt.Printf("GetSecret error executing sql record : '%s'\n", err)
+		log.Printf("GetSecret error executing sql record : '%s'\n", err)
 		return secretResults, err
 	} else {
 		// parse all the results into a slice
@@ -75,20 +75,20 @@ func GetSecrets(s *Secret) ([]Secret, error) {
 			var r Secret
 			err = rows.StructScan(&r)
 			if err != nil {
-				fmt.Printf("GetSecret error parsing sql record : '%s'\n", err)
+				log.Printf("GetSecret error parsing sql record : '%s'\n", err)
 				return secretResults, err
 			}
 
 			// Decrypt the secret
 			_, err = r.DecryptSecret()
 			if err != nil {
-				fmt.Printf("GetSecret unable to decrypt stored secret '%v', skipping result.\n", r.Secret)
+				log.Printf("GetSecret unable to decrypt stored secret '%v', skipping result.\n", r.Secret)
 			} else {
 				secretResults = append(secretResults, r)
 			}
 
 		}
-		fmt.Printf("GetSecret retrieved '%d' results\n", len(secretResults))
+		log.Printf("GetSecret retrieved '%d' results\n", len(secretResults))
 	}
 
 	return secretResults, nil
@@ -98,22 +98,22 @@ func (s *Secret) UpdateSecret() (*Secret, error) {
 
 	var err error
 
-	fmt.Printf("UpdateSecret storing values '%v'\n", s)
+	log.Printf("UpdateSecret storing values '%v'\n", s)
 
 	if s.SecretId == 0 {
 		err = errors.New("UpdateSecret unable to locate secret with empty secretId field")
-		fmt.Printf("UpdateSecret error in pre-check : '%s'\n", err)
+		log.Printf("UpdateSecret error in pre-check : '%s'\n", err)
 		return s, err
 	}
 
 	result, err := db.NamedExec((`UPDATE secrets SET DeviceName = :DeviceName, DeviceCategory = :DeviceCategory, UserName = :UserName, Secret = :Secret WHERE SecretId = :SecretId`), s)
 	if err != nil {
-		fmt.Printf("UpdateSecret error executing sql record : '%s'\n", err)
+		log.Printf("UpdateSecret error executing sql record : '%s'\n", err)
 		return &Secret{}, err
 	} else {
 		affected, _ := result.RowsAffected()
 		id, _ := result.LastInsertId()
-		fmt.Printf("UpdateSecret insert returned result id '%d' affecting %d row(s).\n", id, affected)
+		log.Printf("UpdateSecret insert returned result id '%d' affecting %d row(s).\n", id, affected)
 	}
 
 	return s, nil
@@ -128,35 +128,35 @@ func (s *Secret) EncryptSecret() (*Secret, error) {
 	//key := []byte("ECB518652A170880555136EA1F9752D6")
 	plaintext := []byte(s.Secret)
 
-	fmt.Printf("EncryptSecret applying key '%v' of length '%d' to plaintext secret '%s'\n", key, len(key), s.Secret)
+	log.Printf("EncryptSecret applying key '%v' of length '%d' to plaintext secret '%s'\n", key, len(key), s.Secret)
 
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		fmt.Printf("EncryptSecret NewCipher error '%s'\n", err)
+		log.Printf("EncryptSecret NewCipher error '%s'\n", err)
 		return s, err
 	}
 
 	// Never use more than 2^32 random nonces with a given key because of the risk of a repeat.
 	nonce := make([]byte, nonceSize)
 	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-		fmt.Printf("EncryptSecret nonce generation error '%s'\n", err)
+		log.Printf("EncryptSecret nonce generation error '%s'\n", err)
 		return s, err
 	}
-	fmt.Printf("EncryptSecret random nonce value is '%x'\n", nonce)
+	log.Printf("EncryptSecret random nonce value is '%x'\n", nonce)
 
 	aesgcm, err := cipher.NewGCM(block)
 	if err != nil {
-		fmt.Printf("EncryptSecret NewGCM error '%s'\n", err)
+		log.Printf("EncryptSecret NewGCM error '%s'\n", err)
 		return s, err
 	}
 
 	ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)
-	fmt.Printf("EncryptSecret generated ciphertext '%x''\n", ciphertext)
+	log.Printf("EncryptSecret generated ciphertext '%x''\n", ciphertext)
 
 	// Create a new slice to store nonce at the start and then the resulting ciphertext
 	// Nonce is always 12 bytes
 	combinedText := append(nonce, ciphertext...)
-	fmt.Printf("EncryptSecret combined secret value is now '%x'\n", combinedText)
+	log.Printf("EncryptSecret combined secret value is now '%x'\n", combinedText)
 
 	// Store the value back into the struct ready for database operations
 	s.Secret = hex.EncodeToString(combinedText)
@@ -175,44 +175,44 @@ func (s *Secret) DecryptSecret() (*Secret, error) {
 	//key := []byte("ECB518652A170880555136EA1F9752D6")
 
 	if len(s.Secret) < nonceSize {
-		fmt.Printf("DecryptSecret ciphertext is too short to decrypt\n")
+		log.Printf("DecryptSecret ciphertext is too short to decrypt\n")
 		return s, errors.New("ciphertext is too short")
 	}
 
 	crypted, err := hex.DecodeString(s.Secret)
 	if err != nil {
-		fmt.Printf("DecryptSecret unable to convert hex encoded string due to  error '%s'\n", err)
+		log.Printf("DecryptSecret unable to convert hex encoded string due to  error '%s'\n", err)
 		return s, err
 	}
 
-	fmt.Printf("DecryptSecret processing secret '%x'\n", crypted)
+	log.Printf("DecryptSecret processing secret '%x'\n", crypted)
 
 	//nonce, _ := hex.DecodeString("64a9433eae7ccceee2fc0eda")
 	// The nonce is the first 12 bytes from the ciphertext
 	nonce := crypted[:nonceSize]
 	ciphertext := crypted[nonceSize:]
 
-	fmt.Printf("DecryptSecret applying key '%v' and nonce '%x' to ciphertext '%x'\n", key, nonce, ciphertext)
+	log.Printf("DecryptSecret applying key '%v' and nonce '%x' to ciphertext '%x'\n", key, nonce, ciphertext)
 
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		fmt.Printf("DecryptSecret NewCipher error '%s'\n", err)
+		log.Printf("DecryptSecret NewCipher error '%s'\n", err)
 		return s, err
 	}
 
 	aesgcm, err := cipher.NewGCM(block)
 	if err != nil {
-		fmt.Printf("DecryptSecret NewGCM error '%s'\n", err)
+		log.Printf("DecryptSecret NewGCM error '%s'\n", err)
 		return s, err
 	}
 
 	plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
 	if err != nil {
-		fmt.Printf("DecryptSecret Open error '%s'\n", err)
+		log.Printf("DecryptSecret Open error '%s'\n", err)
 		return s, err
 	}
 
-	fmt.Printf("DecryptSecret plaintext is '%s'\n", plaintext)
+	log.Printf("DecryptSecret plaintext is '%s'\n", plaintext)
 
 	s.Secret = string(plaintext)
 	return s, nil

models/setup.go

@@ -74,10 +74,10 @@ func ConnectDatabase() {
 	db, err = sqlx.Open("sqlite", sqlPath)
 
 	if err != nil {
-		fmt.Printf("Error opening sqlite database connection to file '%s' : '%s'\n", sqlPath, err)
+		log.Printf("Error opening sqlite database connection to file '%s' : '%s'\n", sqlPath, err)
 		os.Exit(1)
 	} else {
-		fmt.Printf("Connected to sqlite database file '%s'\n", sqlPath)
+		log.Printf("Connected to sqlite database file '%s'\n", sqlPath)
 	}
 
 	//sqlx.NameMapper = func(s string) string { return s }
@@ -89,7 +89,7 @@ func ConnectDatabase() {
 }
 
 func DisconnectDatabase() {
-	fmt.Printf("DisconnectDatabase called")
+	log.Printf("DisconnectDatabase called")
 	defer db.Close()
 }
 
@@ -99,28 +99,28 @@ func CreateTables() {
 	// Create database tables if it doesn't exist
 	// Roles table should go first since other tables refer to it
 	if _, err = db.Exec(createRoles); err != nil {
-		fmt.Printf("Error checking roles table : '%s'", err)
+		log.Printf("Error checking roles table : '%s'", err)
 		os.Exit(1)
 	}
 	rowCount, _ = CheckCount("roles")
 	if rowCount == 0 {
 		if _, err = db.Exec("INSERT INTO roles VALUES(1, 'Admin', false, true);"); err != nil {
-			fmt.Printf("Error adding initial admin role : '%s'", err)
+			log.Printf("Error adding initial admin role : '%s'", err)
 			os.Exit(1)
 		}
 		if _, err = db.Exec("INSERT INTO roles VALUES(2, 'UserRole', false, false);"); err != nil {
-			fmt.Printf("Error adding initial user role : '%s'", err)
+			log.Printf("Error adding initial user role : '%s'", err)
 			os.Exit(1)
 		}
 		if _, err = db.Exec("INSERT INTO roles VALUES(3, 'GuestRole', true, false);"); err != nil {
-			fmt.Printf("Error adding initial guest role : '%s'", err)
+			log.Printf("Error adding initial guest role : '%s'", err)
 			os.Exit(1)
 		}
 	}
 
 	// Users table
 	if _, err = db.Exec(createUsers); err != nil {
-		fmt.Printf("Error checking users table : '%s'", err)
+		log.Printf("Error checking users table : '%s'", err)
 		os.Exit(1)
 	}
 	rowCount, _ = CheckCount("users")
@@ -130,30 +130,30 @@ func CreateTables() {
 		if initialPassword == "" {
 			initialPassword = "password"
 		} else if initialPassword[:4] == "$2a$" {
-			fmt.Printf("CreateTables inital admin password is already a hash")
+			log.Printf("CreateTables inital admin password is already a hash")
 		} else {
 			cryptText, _ := bcrypt.GenerateFromPassword([]byte(initialPassword), bcrypt.DefaultCost)
 			initialPassword = string(cryptText)
 		}
 		if _, err = db.Exec("INSERT INTO users VALUES(1, 1, 'Administrator', ?);", initialPassword); err != nil {
-			fmt.Printf("Error adding initial admin role : '%s'", err)
+			log.Printf("Error adding initial admin role : '%s'", err)
 			os.Exit(1)
 		}
 	}
 	// Secrets table
 	if _, err = db.Exec(createSecrets); err != nil {
-		fmt.Printf("Error checking secrets table : '%s'", err)
+		log.Printf("Error checking secrets table : '%s'", err)
 		os.Exit(1)
 	}
 	// Schema table should go last so we know if the database has a value in the schema table then everything was created properly
 	if _, err = db.Exec(createSchema); err != nil {
-		fmt.Printf("Error checking schema table : '%s'", err)
+		log.Printf("Error checking schema table : '%s'", err)
 		os.Exit(1)
 	}
 	schemaCheck, _ := CheckColumnExists("schema", "Version")
 	if !schemaCheck {
 		if _, err = db.Exec("INSERT INTO schema VALUES(1);"); err != nil {
-			fmt.Printf("Error adding initial scehama version : '%s'", err)
+			log.Printf("Error adding initial scehama version : '%s'", err)
 			os.Exit(1)
 		}
 	}
@@ -165,12 +165,12 @@ func CheckCount(tablename string) (int, error) {
 	var count int
 	stmt, err := db.Prepare("SELECT COUNT(*) as count FROM " + tablename)
 	if err != nil {
-		fmt.Printf("CheckCount error preparing sqlite statement : '%s'\n", err)
+		log.Printf("CheckCount error preparing sqlite statement : '%s'\n", err)
 		return 0, err
 	}
 	err = stmt.QueryRow().Scan(&count)
 	if err != nil {
-		fmt.Printf("CheckCount error querying database record count : '%s'\n", err)
+		log.Printf("CheckCount error querying database record count : '%s'\n", err)
 		return 0, err
 	}
 	stmt.Close() // or use defer rows.Close(), idc
@@ -214,7 +214,7 @@ func GenerateInsertMethod(q interface{}) (string, error) {
 					fieldValues = fmt.Sprintf("%s, %d", fieldValues, boolSet)
 				}
 			default:
-				fmt.Printf("Unsupported type '%s'\n", v.Field(i).Kind())
+				log.Printf("Unsupported type '%s'\n", v.Field(i).Kind())
 			}
 		}
 		query = fmt.Sprintf("%s(%s) VALUES (%s)", query, fieldNames, fieldValues)
@@ -227,14 +227,14 @@ func CheckColumnExists(table string, column string) (bool, error) {
 	var count int64
 	rows, err := db.Queryx("SELECT COUNT(*) AS CNTREC FROM pragma_table_info('" + table + "') WHERE name='" + column + "';")
 	if err != nil {
-		fmt.Printf("CheckColumnExists error querying database for existence of column '%s' : '%s'\n", column, err)
+		log.Printf("CheckColumnExists error querying database for existence of column '%s' : '%s'\n", column, err)
 		return false, err
 	}
 	defer rows.Close()
 	for rows.Next() {
 		// cols is an []interface{} of all of the column results
 		cols, _ := rows.SliceScan()
-		fmt.Printf("CheckColumnExists Value is '%v' for table '%s' and column '%s'\n", cols[0].(int64), table, column)
+		log.Printf("CheckColumnExists Value is '%v' for table '%s' and column '%s'\n", cols[0].(int64), table, column)
 		count = cols[0].(int64)
 
 		if count == 1 {
@@ -246,7 +246,7 @@ func CheckColumnExists(table string, column string) (bool, error) {
 
 	err = rows.Err()
 	if err != nil {
-		fmt.Printf("CheckColumnExists error getting results : '%s'\n", err)
+		log.Printf("CheckColumnExists error getting results : '%s'\n", err)
 		return false, err
 	}
 

models/user.go

@@ -3,7 +3,7 @@ package models
 import (
 	"ccsecrets/utils/token"
 	"errors"
-	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -33,19 +33,19 @@ func (u *User) SaveUser() (*User, error) {
 	result, err := db.NamedExec((`INSERT INTO users (RoleId, UserName, Password) VALUES (:RoleId, :UserName, :Password)`), u)
 
 	if err != nil {
-		fmt.Printf("SaveUser error executing sql record : '%s'\n", err)
+		log.Printf("SaveUser error executing sql record : '%s'\n", err)
 		return &User{}, err
 	} else {
 		affected, _ := result.RowsAffected()
 		id, _ := result.LastInsertId()
-		fmt.Printf("SaveUser insert returned result id '%d' affecting %d row(s).\n", id, affected)
+		log.Printf("SaveUser insert returned result id '%d' affecting %d row(s).\n", id, affected)
 	}
 
 	return u, nil
 }
 
 func VerifyPassword(password, hashedPassword string) error {
-	fmt.Printf("VerifyPassword comparing password vs hashed:\n'%s'\n'%s'\n", password, hashedPassword)
+	log.Printf("VerifyPassword comparing password vs hashed:\n'%s'\n'%s'\n", password, hashedPassword)
 	return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
 }
 
@@ -58,7 +58,7 @@ func LoginCheck(username string, password string) (string, error) {
 	// Query database for matching user object
 	err = db.QueryRowx("SELECT * FROM Users WHERE Username=?", username).StructScan(&u)
 
-	fmt.Printf("LoginCheck retrieved user '%v' from database\n", u)
+	log.Printf("LoginCheck retrieved user '%v' from database\n", u)
 
 	if err != nil {
 		return "", err
@@ -67,16 +67,16 @@ func LoginCheck(username string, password string) (string, error) {
 	err = VerifyPassword(password, u.Password)
 
 	if err != nil && err == bcrypt.ErrMismatchedHashAndPassword {
-		fmt.Printf("LoginCheck says password doesn't match stored hash.\n")
+		log.Printf("LoginCheck says password doesn't match stored hash.\n")
 		return "", err
 	} else {
-		fmt.Printf("LoginCheck verified password against stored hash.\n")
+		log.Printf("LoginCheck verified password against stored hash.\n")
 	}
 
 	token, err := token.GenerateToken(uint(u.UserId))
 
 	if err != nil {
-		fmt.Printf("LoginCheck error generating token : '%s'\n", err)
+		log.Printf("LoginCheck error generating token : '%s'\n", err)
 		return "", err
 	}
 
@@ -122,10 +122,10 @@ func GetUserRoleByID(uid uint) (UserRole, error) {
 	var ur UserRole
 
 	// Query database for matching user object
-	fmt.Printf("GetUserRoleByID querying for userid '%d'\n", uid)
+	log.Printf("GetUserRoleByID querying for userid '%d'\n", uid)
 	err := db.QueryRowx("SELECT users.UserId, users.RoleId, users.UserName, users.Password, roles.RoleName, roles.ReadOnly, roles.Admin FROM users INNER JOIN roles ON users.RoleId = roles.RoleId WHERE users.UserId=?", uid).StructScan(&ur)
 	if err != nil {
-		fmt.Printf("GetUserRoleByID received error when querying database : '%s'\n", err)
+		log.Printf("GetUserRoleByID received error when querying database : '%s'\n", err)
 		return ur, errors.New("GetUserRoleByID user not found")
 	}
 
@@ -144,10 +144,10 @@ func GetUserRoleFromToken(c *gin.Context) (UserRole, error) {
 	}
 
 	// Query database for matching user object
-	fmt.Printf("GetUserRoleFromToken querying for userid '%d'\n", user_id)
+	log.Printf("GetUserRoleFromToken querying for userid '%d'\n", user_id)
 	err = db.QueryRowx("SELECT users.UserId, users.RoleId, users.UserName, users.Password, roles.RoleName, roles.ReadOnly, roles.Admin FROM users INNER JOIN roles ON users.RoleId = roles.RoleId WHERE users.UserId=?", user_id).StructScan(&ur)
 	if err != nil {
-		fmt.Printf("GetUserRoleFromToken received error when querying database : '%s'\n", err)
+		log.Printf("GetUserRoleFromToken received error when querying database : '%s'\n", err)
 		return ur, errors.New("GetUserRoleFromToken user not found")
 	}
 

utils/token/token.go

@@ -2,6 +2,7 @@ package token
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"strconv"
 	"strings"
@@ -15,7 +16,7 @@ func GenerateToken(user_id uint) (string, error) {
 
 	token_lifespan, err := strconv.Atoi(os.Getenv("TOKEN_HOUR_LIFESPAN"))
 	if err != nil {
-		fmt.Printf("GenerateToken Error getting env value TOKEN_HOUR_LIFESPAN\n")
+		log.Printf("GenerateToken Error getting env value TOKEN_HOUR_LIFESPAN\n")
 		return "", err
 	}
 

utils/utils.go

@@ -6,7 +6,6 @@ import (
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"encoding/pem"
-	"fmt"
 	"log"
 	"math/big"
 	"net"
@@ -25,7 +24,7 @@ func GetFilePath(path string) string {
 
 	// check if filename exists
 	if _, err := os.Stat(path); os.IsNotExist((err)) {
-		fmt.Printf("File '%s' not found, searching in same directory as binary\n", path)
+		log.Printf("File '%s' not found, searching in same directory as binary\n", path)
 		// if not, check that it exists in the same directory as the currently executing binary
 		ex, err2 := os.Executable()
 		if err2 != nil {
@@ -76,7 +75,7 @@ func GenerateCerts(tlsCert string, tlsKey string) {
 
 	// Check that the directory exists
 	relativePath := filepath.Dir(tlsCert)
-	fmt.Printf("GenerateCerts relative path for file creation is '%s'\n", relativePath)
+	log.Printf("GenerateCerts relative path for file creation is '%s'\n", relativePath)
 	_, err = os.Stat(relativePath)
 	if os.IsNotExist(err) {
 		log.Printf("Certificate path does not exist, creating %s before generating certificate\n", relativePath)
@@ -126,13 +125,13 @@ func GenerateCerts(tlsCert string, tlsKey string) {
 	ifaces, err := net.Interfaces()
 
 	if err != nil {
-		fmt.Printf("Error enumerating interfaces: %v\n", err)
+		log.Printf("Error enumerating interfaces: %v\n", err)
 	}
 
 	for _, i := range ifaces {
 		addrs, err := i.Addrs()
 		if err != nil {
-			fmt.Printf("Oops: %v\n", err)
+			log.Printf("Oops: %v\n", err)
 		}
 
 		for _, address := range addrs {