Migrated all root source code to use common module

agi.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	agi "imuslab.com/arozos/mod/agi"
+	"imuslab.com/arozos/mod/common"
 )
 
 var (
@@ -44,7 +45,7 @@ func AGIInit() {
 	//Register external API request handler endpoint
 	http.HandleFunc("/api/ajgi/interface", func(w http.ResponseWriter, r *http.Request) {
 		//Check if token exists
-		token, err := mv(r, "token", true)
+		token, err := common.Mv(r, "token", true)
 		if err != nil {
 			w.WriteHeader(http.StatusUnauthorized)
 			w.Write([]byte("401 - Unauthorized (token is empty)"))

apt.go

@@ -1,28 +1,30 @@
 package main
 
 import (
-	"net/http"
 	"log"
-	prout "imuslab.com/arozos/mod/prouter"
+	"net/http"
+
 	apt "imuslab.com/arozos/mod/apt"
+	"imuslab.com/arozos/mod/common"
+	prout "imuslab.com/arozos/mod/prouter"
 )
 
-func PackagManagerInit(){
+func PackagManagerInit() {
 	//Create a package manager
-	packageManager = apt.NewPackageManager(*allow_package_autoInstall);
+	packageManager = apt.NewPackageManager(*allow_package_autoInstall)
 	log.Println("Package Manager Initiated")
 
-	//Create a System Setting handler 
+	//Create a System Setting handler
 	//aka who can access System Setting can see contents about packages
 	router := prout.NewModuleRouter(prout.RouterOption{
-		ModuleName: "System Setting", 
-		AdminOnly: false, 
-		UserHandler: userHandler, 
-		DeniedHandler: func(w http.ResponseWriter, r *http.Request){
-			sendErrorResponse(w, "Permission Denied");
+		ModuleName:  "System Setting",
+		AdminOnly:   false,
+		UserHandler: userHandler,
+		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
+			common.SendErrorResponse(w, "Permission Denied")
 		},
-	});
-	
+	})
+
 	//Handle package listing request
 	router.HandleFunc("/system/apt/list", apt.HandlePackageListRequest)
 

auth.go

@@ -61,7 +61,7 @@ func AuthSettingsInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 

backup.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"imuslab.com/arozos/mod/common"
 	"imuslab.com/arozos/mod/disk/hybridBackup"
 	user "imuslab.com/arozos/mod/user"
 
@@ -19,7 +20,7 @@ func backup_init() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -88,7 +89,7 @@ func backup_listAllBackupDisk(w http.ResponseWriter, r *http.Request) {
 
 		//Check for error in getting FS Handler
 		if diskErr != nil || parentErr != nil {
-			sendErrorResponse(w, "Unable to get backup task info from backup disk: "+task.DiskUID)
+			common.SendErrorResponse(w, "Unable to get backup task info from backup disk: "+task.DiskUID)
 			return
 		}
 
@@ -108,7 +109,7 @@ func backup_listAllBackupDisk(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(backupDrives)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 //Generate a snapshot summary for vroot
@@ -116,47 +117,47 @@ func backup_renderSnapshotSummary(w http.ResponseWriter, r *http.Request) {
 	//Get user accessiable storage pools
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	//Get Backup disk ID from request
-	bdid, err := mv(r, "bdid", true)
+	bdid, err := common.Mv(r, "bdid", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid backup disk ID given")
+		common.SendErrorResponse(w, "Invalid backup disk ID given")
 		return
 	}
 
 	//Get target snapshot name from request
-	snapshot, err := mv(r, "snapshot", true)
+	snapshot, err := common.Mv(r, "snapshot", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid snapshot name given")
+		common.SendErrorResponse(w, "Invalid snapshot name given")
 		return
 	}
 
 	//Get fsh from the id
 	fsh, err := GetFsHandlerByUUID(bdid)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get parent disk hierarcy
 	parentDiskID, err := userinfo.HomeDirectories.HyperBackupManager.GetParentDiskIDByRestoreDiskID(fsh.UUID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 	parentFsh, err := GetFsHandlerByUUID(parentDiskID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get task by the backup disk id
 	task, err := userinfo.HomeDirectories.HyperBackupManager.GetTaskByBackupDiskID(fsh.UUID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -166,23 +167,23 @@ func backup_renderSnapshotSummary(w http.ResponseWriter, r *http.Request) {
 		if parentFsh.Hierarchy == "user" {
 			s, err := task.GenerateSnapshotSummary(snapshot, &userinfo.Username)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 				return
 			}
 			summary = s
 		} else {
 			s, err := task.GenerateSnapshotSummary(snapshot, nil)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 				return
 			}
 			summary = s
 		}
 
 		js, _ := json.Marshal(summary)
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 	} else {
-		sendErrorResponse(w, "Unable to genreate snapshot summary: Backup mode is not snapshot")
+		common.SendErrorResponse(w, "Unable to genreate snapshot summary: Backup mode is not snapshot")
 		return
 	}
 
@@ -193,42 +194,42 @@ func backup_restoreSelected(w http.ResponseWriter, r *http.Request) {
 	//Get user accessiable storage pools
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	//Get Backup disk ID from request
-	bdid, err := mv(r, "bdid", true)
+	bdid, err := common.Mv(r, "bdid", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid backup disk ID given")
+		common.SendErrorResponse(w, "Invalid backup disk ID given")
 		return
 	}
 
 	//Get fsh from the id
 	fsh, err := GetFsHandlerByUUID(bdid)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get the relative path for the restorable file
-	relpath, err := mv(r, "relpath", true)
+	relpath, err := common.Mv(r, "relpath", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid relative path given")
+		common.SendErrorResponse(w, "Invalid relative path given")
 		return
 	}
 
 	//Pick the correct HybridBackup Manager
 	targetHybridBackupManager, err := backup_pickHybridBackupManager(userinfo, fsh.UUID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Handle restore of the file
 	err = targetHybridBackupManager.HandleRestore(fsh.UUID, relpath, &userinfo.Username)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -263,7 +264,7 @@ func backup_restoreSelected(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(result)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 //As one user might be belongs to multiple groups, check which storage pool is this disk ID owned by and return its corect backup maanger
@@ -296,42 +297,42 @@ func backup_listRestorable(w http.ResponseWriter, r *http.Request) {
 	//Get user accessiable storage pools
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	//Get Vroot ID from request
-	vroot, err := mv(r, "vroot", true)
+	vroot, err := common.Mv(r, "vroot", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid vroot given")
+		common.SendErrorResponse(w, "Invalid vroot given")
 		return
 	}
 
 	//Get fsh from the id
 	fsh, err := GetFsHandlerByUUID(vroot)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get all backup managers that this user ac can access
 	targetBackupManager, err := backup_pickHybridBackupManager(userinfo, vroot)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get the user's storage pool and list restorable by the user's storage pool access
 	restorableReport, err := targetBackupManager.ListRestorable(fsh.UUID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Get and check if the parent disk has a user Hierarcy
 	paretnfsh, err := GetFsHandlerByUUID(restorableReport.ParentUID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -364,5 +365,5 @@ func backup_listRestorable(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(result)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }

console.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"io/ioutil"
 	"strings"
+
+	"imuslab.com/arozos/mod/common"
 )
 
 //Handle console command from the console module
@@ -86,7 +88,7 @@ func consoleCommandHandler(input string) string {
 				tableList = append(tableList, k.(string))
 				return true
 			})
-			if !inArray(tableList, chunk[2]) {
+			if !common.StringInArray(tableList, chunk[2]) {
 				return "Table not exists"
 			} else if chunk[2] == "auth" {
 				return "You cannot view this database table"

desktop.go

@@ -11,6 +11,8 @@ import (
 	"strconv"
 	"strings"
 
+	"imuslab.com/arozos/mod/common"
+	fs "imuslab.com/arozos/mod/filesystem"
 	module "imuslab.com/arozos/mod/modules"
 	prout "imuslab.com/arozos/mod/prouter"
 )
@@ -24,7 +26,7 @@ func DesktopInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -74,12 +76,12 @@ func desktop_initUserFolderStructure(username string) {
 		log.Println(err)
 	}
 
-	if !fileExists(filepath.Join(homedir, "Desktop")) {
+	if !fs.FileExists(filepath.Join(homedir, "Desktop")) {
 		//Desktop directory not exists. Create one and copy a template desktop
 		os.MkdirAll(homedir+"Desktop", 0755)
 
 		templateFolder := "./system/desktop/template/"
-		if fileExists(templateFolder) {
+		if fs.FileExists(templateFolder) {
 			templateFiles, _ := filepath.Glob(templateFolder + "*")
 			for _, tfile := range templateFiles {
 				input, _ := ioutil.ReadFile(tfile)
@@ -112,59 +114,59 @@ func desktop_hostdetailHandler(w http.ResponseWriter, r *http.Request) {
 		VendorIcon:      iconVendor,
 	})
 
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func desktop_handleShortcutRename(w http.ResponseWriter, r *http.Request) {
 	//Check if the user directory already exists
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	//Get the shortcut file that is renaming
-	target, err := mv(r, "src", false)
+	target, err := common.Mv(r, "src", false)
 	if err != nil {
-		sendErrorResponse(w, "Invalid shortcut file path given")
+		common.SendErrorResponse(w, "Invalid shortcut file path given")
 		return
 	}
 
 	//Get the new name
-	new, err := mv(r, "new", false)
+	new, err := common.Mv(r, "new", false)
 	if err != nil {
-		sendErrorResponse(w, "Invalid new name given")
+		common.SendErrorResponse(w, "Invalid new name given")
 		return
 	}
 
 	//Check if the file actually exists and it is on desktop
 	rpath, err := userinfo.VirtualPathToRealPath(target)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	if target[:14] != "user:/Desktop/" {
-		sendErrorResponse(w, "Shortcut not on desktop")
+		common.SendErrorResponse(w, "Shortcut not on desktop")
 		return
 	}
 
-	if !fileExists(rpath) {
-		sendErrorResponse(w, "File not exists")
+	if !fs.FileExists(rpath) {
+		common.SendErrorResponse(w, "File not exists")
 		return
 	}
 
 	//OK. Change the name of the shortcut
 	originalShortcut, err := ioutil.ReadFile(rpath)
 	if err != nil {
-		sendErrorResponse(w, "Shortcut file read failed")
+		common.SendErrorResponse(w, "Shortcut file read failed")
 		return
 	}
 
 	lines := strings.Split(string(originalShortcut), "\n")
 	if len(lines) < 4 {
 		//Invalid shortcut properties
-		sendErrorResponse(w, "Invalid shortcut file")
+		common.SendErrorResponse(w, "Invalid shortcut file")
 		return
 	}
 
@@ -173,10 +175,10 @@ func desktop_handleShortcutRename(w http.ResponseWriter, r *http.Request) {
 	newShortcutContent := strings.Join(lines, "\n")
 	err = ioutil.WriteFile(rpath, []byte(newShortcutContent), 0755)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func desktop_listFiles(w http.ResponseWriter, r *http.Request) {
@@ -224,7 +226,7 @@ func desktop_listFiles(w http.ResponseWriter, r *http.Request) {
 		thisFileObject.Filepath, _ = userinfo.RealPathToVirtualPath(this)
 		thisFileObject.Filename = filepath.Base(this)
 		thisFileObject.Ext = filepath.Ext(this)
-		thisFileObject.IsDir = IsDir(this)
+		thisFileObject.IsDir = fs.IsDir(this)
 		if thisFileObject.IsDir {
 			//Check if this dir is empty
 			filesInFolder, _ := filepath.Glob(filepath.ToSlash(filepath.Clean(this)) + "/*")
@@ -275,7 +277,7 @@ func desktop_listFiles(w http.ResponseWriter, r *http.Request) {
 
 	//Convert the struct to json string
 	jsonString, _ := json.Marshal(desktopFiles)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 //functions to handle desktop icon locations. Location is directly written into the center db.
@@ -316,7 +318,7 @@ func setDesktopLocationFromPath(filename string, username string, x int, y int)
 	newLocation.Y = y
 
 	//Check if the file exits
-	if fileExists(path) == false {
+	if fs.FileExists(path) == false {
 		return errors.New("Given filename not exists.")
 	}
 
@@ -342,7 +344,7 @@ func delDesktopLocationFromPath(filename string, username string) {
 func desktop_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -375,21 +377,21 @@ func desktop_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		StorageQuotaTotal: userinfo.StorageQuota.GetUserStorageQuota(),
 		StorageQuotaLeft:  remainingQuota,
 	})
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 //Icon handling function for web endpoint
 func desktop_fileLocation_handler(w http.ResponseWriter, r *http.Request) {
-	get, _ := mv(r, "get", true) //Check if there are get request for a given filepath
-	set, _ := mv(r, "set", true) //Check if there are any set request for a given filepath
-	del, _ := mv(r, "del", true) //Delete the given filename coordinate
+	get, _ := common.Mv(r, "get", true) //Check if there are get request for a given filepath
+	set, _ := common.Mv(r, "set", true) //Check if there are any set request for a given filepath
+	del, _ := common.Mv(r, "del", true) //Delete the given filename coordinate
 
 	if set != "" {
 		//Set location with given paramter
 		x := 0
 		y := 0
-		sx, _ := mv(r, "x", true)
-		sy, _ := mv(r, "y", true)
+		sx, _ := common.Mv(r, "x", true)
+		sy, _ := common.Mv(r, "y", true)
 		path := set
 
 		x, err := strconv.Atoi(sx)
@@ -406,22 +408,22 @@ func desktop_fileLocation_handler(w http.ResponseWriter, r *http.Request) {
 		username, _ := authAgent.GetUserName(w, r)
 		err = setDesktopLocationFromPath(path, username, x, y)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
-		sendJSONResponse(w, string("\"OK\""))
+		common.SendJSONResponse(w, string("\"OK\""))
 	} else if get != "" {
 		username, _ := authAgent.GetUserName(w, r)
 		x, y, _ := getDesktopLocatioFromPath(get, username)
 		result := []int{x, y}
 		json_string, _ := json.Marshal(result)
-		sendJSONResponse(w, string(json_string))
+		common.SendJSONResponse(w, string(json_string))
 	} else if del != "" {
 		username, _ := authAgent.GetUserName(w, r)
 		delDesktopLocationFromPath(del, username)
 	} else {
 		//No argument has been set
-		sendTextResponse(w, "Paramter missing.")
+		common.SendJSONResponse(w, "Paramter missing.")
 	}
 }
 
@@ -430,15 +432,15 @@ func desktop_fileLocation_handler(w http.ResponseWriter, r *http.Request) {
 func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 	username := userinfo.Username
 
 	//Check if the set GET paramter is set.
-	targetTheme, _ := mv(r, "set", false)
-	getUserTheme, _ := mv(r, "get", false)
-	loadUserTheme, _ := mv(r, "load", false)
+	targetTheme, _ := common.Mv(r, "set", false)
+	getUserTheme, _ := common.Mv(r, "get", false)
+	loadUserTheme, _ := common.Mv(r, "load", false)
 	if targetTheme == "" && getUserTheme == "" && loadUserTheme == "" {
 		//List all the currnet themes in the list
 		themes, err := filepath.Glob("web/img/desktop/bg/*")
@@ -460,7 +462,7 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 			".gif",
 		}
 		for _, file := range themes {
-			if IsDir(file) {
+			if fs.IsDir(file) {
 				thisTheme := new(desktopTheme)
 				thisTheme.Theme = filepath.Base(file)
 				bglist, _ := filepath.Glob(file + "/*")
@@ -468,7 +470,7 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 				for _, bg := range bglist {
 					ext := filepath.Ext(bg)
 					//if (sliceutil.Contains(acceptBGFormats, ext) ){
-					if stringInSlice(ext, acceptBGFormats) {
+					if common.StringInArray(acceptBGFormats, ext) {
 						//This file extension is supported
 						thisbglist = append(thisbglist, filepath.Base(bg))
 					}
@@ -484,7 +486,7 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 		if err != nil {
 			log.Fatal(err)
 		}
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 		return
 	} else if getUserTheme == "true" {
 		//Get the user's theme from database
@@ -492,30 +494,30 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 		sysdb.Read("desktop", username+"/theme", &result)
 		if result == "" {
 			//This user has not set a theme yet. Use default
-			sendJSONResponse(w, string("\"default\""))
+			common.SendJSONResponse(w, string("\"default\""))
 			return
 		} else {
 			//This user already set a theme. Use its set theme
-			sendJSONResponse(w, string("\""+result+"\""))
+			common.SendJSONResponse(w, string("\""+result+"\""))
 			return
 		}
 	} else if loadUserTheme != "" {
 		//Load user theme base on folder path
 		rpath, err := userinfo.VirtualPathToRealPath(loadUserTheme)
 		if err != nil {
-			sendErrorResponse(w, "Custom folder load failed")
+			common.SendErrorResponse(w, "Custom folder load failed")
 			return
 		}
 
 		//Check if the folder exists
-		if !fileExists(rpath) {
-			sendErrorResponse(w, "Custom folder load failed")
+		if !fs.FileExists(rpath) {
+			common.SendErrorResponse(w, "Custom folder load failed")
 			return
 		}
 
 		if userinfo.CanRead(loadUserTheme) == false {
 			//No read permission
-			sendErrorResponse(w, "Permission denied")
+			common.SendErrorResponse(w, "Permission denied")
 			return
 		}
 
@@ -543,50 +545,50 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 		}
 
 		js, _ := json.Marshal(virtualImageList)
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 
 	} else if targetTheme != "" {
 		//Set the current user theme
 		sysdb.Write("desktop", username+"/theme", targetTheme)
-		sendJSONResponse(w, "\"OK\"")
+		common.SendJSONResponse(w, "\"OK\"")
 		return
 	}
 
 }
 
 func desktop_preference_handler(w http.ResponseWriter, r *http.Request) {
-	preferenceType, _ := mv(r, "preference", false)
-	value, _ := mv(r, "value", false)
-	remove, _ := mv(r, "remove", false)
+	preferenceType, _ := common.Mv(r, "preference", false)
+	value, _ := common.Mv(r, "value", false)
+	remove, _ := common.Mv(r, "remove", false)
 	username, err := authAgent.GetUserName(w, r)
 	if err != nil {
 		//user not logged in. Redirect to login page.
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 	if preferenceType == "" && value == "" {
 		//Invalid options. Return error reply.
-		sendTextResponse(w, "Error. Undefined paramter.")
+		common.SendErrorResponse(w, "Error. Undefined paramter.")
 		return
 	} else if preferenceType != "" && value == "" && remove == "" {
 		//Getting config from the key.
 		result := ""
 		sysdb.Read("desktop", username+"/preference/"+preferenceType, &result)
 		jsonString, _ := json.Marshal(result)
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 		return
 	} else if preferenceType != "" && value == "" && remove == "true" {
 		//Remove mode
 		sysdb.Delete("desktop", username+"/preference/"+preferenceType)
-		sendOK(w)
+		common.SendOK(w)
 		return
 	} else if preferenceType != "" && value != "" {
 		//Setting config from the key
 		sysdb.Write("desktop", username+"/preference/"+preferenceType, value)
-		sendJSONResponse(w, "\"OK\"")
+		common.SendOK(w)
 		return
 	} else {
-		sendTextResponse(w, "Error. Undefined paramter.")
+		common.SendErrorResponse(w, "Error. Undefined paramter.")
 		return
 	}
 
@@ -597,44 +599,44 @@ func desktop_shortcutHandler(w http.ResponseWriter, r *http.Request) {
 
 	if err != nil {
 		//user not logged in. Redirect to login page.
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	userinfo, _ := userHandler.GetUserInfoFromUsername(username)
 
-	shortcutType, err := mv(r, "stype", true)
+	shortcutType, err := common.Mv(r, "stype", true)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutText, err := mv(r, "stext", true)
+	shortcutText, err := common.Mv(r, "stext", true)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutPath, err := mv(r, "spath", true)
+	shortcutPath, err := common.Mv(r, "spath", true)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutIcon, err := mv(r, "sicon", true)
+	shortcutIcon, err := common.Mv(r, "sicon", true)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//OK to proceed. Generate a shortcut on the user desktop
 	userDesktopPath, _ := userinfo.VirtualPathToRealPath("user:/Desktop")
-	if !fileExists(userDesktopPath) {
+	if !fs.FileExists(userDesktopPath) {
 		os.MkdirAll(userDesktopPath, 0755)
 	}
 
 	//Check if there are desktop icon. If yes, override icon on module
-	if shortcutType == "module" && fileExists("./web/"+filepath.ToSlash(filepath.Dir(shortcutIcon)+"/desktop_icon.png")) {
+	if shortcutType == "module" && fs.FileExists("./web/"+filepath.ToSlash(filepath.Dir(shortcutIcon)+"/desktop_icon.png")) {
 		shortcutIcon = filepath.ToSlash(filepath.Join(filepath.Dir(shortcutIcon), "/desktop_icon.png"))
 	}
 
@@ -644,14 +646,14 @@ func desktop_shortcutHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	shortcutFilename := userDesktopPath + "/" + shortcutText + ".shortcut"
 	counter := 1
-	for fileExists(shortcutFilename) {
-		shortcutFilename = userDesktopPath + "/" + shortcutText + "(" + IntToString(counter) + ")" + ".shortcut"
+	for fs.FileExists(shortcutFilename) {
+		shortcutFilename = userDesktopPath + "/" + shortcutText + "(" + strconv.Itoa(counter) + ")" + ".shortcut"
 		counter++
 	}
 	err = ioutil.WriteFile(shortcutFilename, []byte(shortcutType+"\n"+shortcutText+"\n"+shortcutPath+"\n"+shortcutIcon), 0755)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
-	sendOK(w)
+	common.SendOK(w)
 }

disk.go

@@ -10,6 +10,7 @@ import (
 	"log"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	"imuslab.com/arozos/mod/disk/diskcapacity"
 	"imuslab.com/arozos/mod/disk/diskmg"
 	diskspace "imuslab.com/arozos/mod/disk/diskspace"
@@ -26,7 +27,7 @@ func DiskServiceInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -71,7 +72,7 @@ func DiskServiceInit() {
 			AdminOnly:   true,
 			UserHandler: userHandler,
 			DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-				sendErrorResponse(w, "Permission Denied")
+				common.SendErrorResponse(w, "Permission Denied")
 			},
 		})
 

error.go

@@ -9,11 +9,13 @@ import (
 	"io/ioutil"
 	"net/http"
 	"strings"
+
+	fs "imuslab.com/arozos/mod/filesystem"
 )
 
 func errorHandleNotFound(w http.ResponseWriter, r *http.Request) {
 	notFoundPage := "./web/SystemAO/notfound.html"
-	if fileExists(notFoundPage) {
+	if fs.FileExists(notFoundPage) {
 
 		notFoundTemplateBytes, err := ioutil.ReadFile(notFoundPage)
 		notFoundTemplate := string(notFoundTemplateBytes)
@@ -35,7 +37,7 @@ func errorHandleNotFound(w http.ResponseWriter, r *http.Request) {
 
 func errorHandlePermissionDenied(w http.ResponseWriter, r *http.Request) {
 	unauthorizedPage := "./web/SystemAO/unauthorized.html"
-	if fileExists(unauthorizedPage) {
+	if fs.FileExists(unauthorizedPage) {
 		notFoundTemplateBytes, err := ioutil.ReadFile(unauthorizedPage)
 		notFoundTemplate := string(notFoundTemplateBytes)
 		if err != nil {

hardware.power.go

@@ -6,6 +6,8 @@ import (
 
 	"os/exec"
 	"runtime"
+
+	"imuslab.com/arozos/mod/common"
 )
 
 func HardwarePowerInit() {
@@ -30,9 +32,9 @@ func HardwarePowerInit() {
 
 func hardware_power_checkIfHardware(w http.ResponseWriter, r *http.Request) {
 	if *allow_hardware_management {
-		sendJSONResponse(w, "true")
+		common.SendJSONResponse(w, "true")
 	} else {
-		sendJSONResponse(w, "false")
+		common.SendJSONResponse(w, "false")
 	}
 }
 
@@ -45,25 +47,25 @@ func hardware_power_poweroff(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if !userinfo.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
 	if !sudo_mode {
-		sendErrorResponse(w, "Sudo mode required")
+		common.SendErrorResponse(w, "Sudo mode required")
 		return
 	}
 
 	//Double check password for this user
-	password, err := mv(r, "password", true)
+	password, err := common.Mv(r, "password", true)
 	if err != nil {
-		sendErrorResponse(w, "Password Incorrect")
+		common.SendErrorResponse(w, "Password Incorrect")
 		return
 	}
 
 	passwordCorrect, rejectionReason := authAgent.ValidateUsernameAndPasswordWithReason(userinfo.Username, password)
 	if !passwordCorrect {
-		sendErrorResponse(w, rejectionReason)
+		common.SendErrorResponse(w, rejectionReason)
 		return
 	}
 
@@ -73,7 +75,7 @@ func hardware_power_poweroff(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
@@ -84,7 +86,7 @@ func hardware_power_poweroff(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
@@ -95,12 +97,12 @@ func hardware_power_poweroff(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
@@ -112,25 +114,25 @@ func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if !userinfo.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
 	if !sudo_mode {
-		sendErrorResponse(w, "Sudo mode required")
+		common.SendErrorResponse(w, "Sudo mode required")
 		return
 	}
 
 	//Double check password for this user
-	password, err := mv(r, "password", true)
+	password, err := common.Mv(r, "password", true)
 	if err != nil {
-		sendErrorResponse(w, "Password Incorrect")
+		common.SendErrorResponse(w, "Password Incorrect")
 		return
 	}
 
 	passwordCorrect, rejectionReason := authAgent.ValidateUsernameAndPasswordWithReason(userinfo.Username, password)
 	if !passwordCorrect {
-		sendErrorResponse(w, rejectionReason)
+		common.SendErrorResponse(w, rejectionReason)
 		return
 	}
 
@@ -140,7 +142,7 @@ func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
@@ -151,7 +153,7 @@ func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
@@ -162,9 +164,9 @@ func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
 		out, err := cmd.CombinedOutput()
 		if err != nil {
 			log.Println(string(out))
-			sendErrorResponse(w, string(out))
+			common.SendErrorResponse(w, string(out))
 		}
 		log.Println(string(out))
 	}
-	sendOK(w)
+	common.SendOK(w)
 }

iot.go

@@ -3,6 +3,7 @@ package main
 import (
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	"imuslab.com/arozos/mod/iot"
 	"imuslab.com/arozos/mod/iot/hds"
 	"imuslab.com/arozos/mod/iot/hdsv2"
@@ -56,7 +57,7 @@ func IoTHubInit() {
 			AdminOnly:   false,
 			UserHandler: userHandler,
 			DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-				sendErrorResponse(w, "Permission Denied")
+				common.SendErrorResponse(w, "Permission Denied")
 			},
 		})
 
@@ -65,7 +66,7 @@ func IoTHubInit() {
 			AdminOnly:   true,
 			UserHandler: userHandler,
 			DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-				sendErrorResponse(w, "Permission Denied")
+				common.SendErrorResponse(w, "Permission Denied")
 			},
 		})
 

main.router.go

@@ -29,14 +29,14 @@ func mrouter(h http.Handler) http.Handler {
 		} else if r.URL.Path == "/login.system" {
 			//Login page. Require special treatment for template.
 			//Get the redirection address from the request URL
-			red, _ := mv(r, "redirect", false)
+			red, _ := common.Mv(r, "redirect", false)
 
 			//Append the redirection addr into the template
 			imgsrc := "./web/" + iconSystem
-			if !fileExists(imgsrc) {
+			if !fs.FileExists(imgsrc) {
 				imgsrc = "./web/img/public/auth_icon.png"
 			}
-			imageBase64, _ := LoadImageAsBase64(imgsrc)
+			imageBase64, _ := common.LoadImageAsBase64(imgsrc)
 			parsedPage, err := common.Templateload("web/login.system", map[string]interface{}{
 				"redirection_addr": red,
 				"usercount":        strconv.Itoa(authAgent.GetUserCounts()),
@@ -130,7 +130,7 @@ func mrouter(h http.Handler) http.Handler {
 			if !*enable_dir_listing {
 				if strings.HasSuffix(r.URL.Path, "/") {
 					//User trying to access a directory. Send NOT FOUND.
-					if fileExists("web" + r.URL.Path + "index.html") {
+					if fs.FileExists("web" + r.URL.Path + "index.html") {
 						//Index exists. Allow passthrough
 
 					} else {
@@ -139,7 +139,7 @@ func mrouter(h http.Handler) http.Handler {
 					}
 				}
 			}
-			if !fileExists("web" + r.URL.Path) {
+			if !fs.FileExists("web" + r.URL.Path) {
 				//File not found
 				errorHandleNotFound(w, r)
 				return

mediaServer.go

@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"imuslab.com/arozos/mod/common"
 	fs "imuslab.com/arozos/mod/filesystem"
 	"imuslab.com/arozos/mod/network/gzipmiddleware"
 )
@@ -54,7 +55,7 @@ func media_server_validateSourceFile(w http.ResponseWriter, r *http.Request) (st
 		return "", errors.New("Invalid paramters. Multiple ? found")
 	}
 
-	targetfile, _ := mv(r, "file", false)
+	targetfile, _ := common.Mv(r, "file", false)
 	targetfile, err = url.QueryUnescape(targetfile)
 	if targetfile == "" {
 		return "", errors.New("Missing paramter 'file'")
@@ -62,14 +63,14 @@ func media_server_validateSourceFile(w http.ResponseWriter, r *http.Request) (st
 
 	//Translate the virtual directory to realpath
 	realFilepath, err := userinfo.VirtualPathToRealPath(targetfile)
-	if fileExists(realFilepath) && IsDir(realFilepath) {
+	if fs.FileExists(realFilepath) && fs.IsDir(realFilepath) {
 		return "", errors.New("Given path is not a file.")
 	}
 	if err != nil {
 		return "", errors.New("Unable to translate the given filepath")
 	}
 
-	if !fileExists(realFilepath) {
+	if !fs.FileExists(realFilepath) {
 		//Sometime if url is not URL encoded, this error might be shown as well
 
 		//Try to use manual segmentation
@@ -92,7 +93,7 @@ func media_server_validateSourceFile(w http.ResponseWriter, r *http.Request) (st
 			log.Println("Error when trying to serve file in compatibility mode", err.Error())
 			return "", errors.New("Error when trying to serve file in compatibility mode")
 		}
-		if fileExists(possibleRealpath) {
+		if fs.FileExists(possibleRealpath) {
 			realFilepath = possibleRealpath
 			log.Println("[Media Server] Serving file " + filepath.Base(possibleRealpath) + " in compatibility mode. Do not to use '&' or '+' sign in filename! ")
 			return realFilepath, nil
@@ -107,11 +108,11 @@ func media_server_validateSourceFile(w http.ResponseWriter, r *http.Request) (st
 func serveMediaMime(w http.ResponseWriter, r *http.Request) {
 	realFilepath, err := media_server_validateSourceFile(w, r)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 	mime := "text/directory"
-	if !IsDir(realFilepath) {
+	if !fs.IsDir(realFilepath) {
 		m, _, err := fs.GetMime(realFilepath)
 		if err != nil {
 			mime = ""
@@ -119,20 +120,20 @@ func serveMediaMime(w http.ResponseWriter, r *http.Request) {
 		mime = m
 	}
 
-	sendTextResponse(w, mime)
+	common.SendTextResponse(w, mime)
 }
 
 func serverMedia(w http.ResponseWriter, r *http.Request) {
 	//Serve normal media files
 	realFilepath, err := media_server_validateSourceFile(w, r)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	//Check if downloadMode
 	downloadMode := false
-	dw, _ := mv(r, "download", false)
+	dw, _ := common.Mv(r, "download", false)
 	if dw == "true" {
 		downloadMode = true
 	}

mod/common/common.go

@@ -131,3 +131,13 @@ func ConstructRelativePathFromRequestURL(requestURI string, redirectionLocation
 
 	return redirectionLocation
 }
+
+//Check if given string in a given slice
+func StringInArray(arr []string, str string) bool {
+	for _, a := range arr {
+		if a == str {
+			return true
+		}
+	}
+	return false
+}

mod/common/conv.go

@@ -0,0 +1,16 @@
+package common
+
+import "strconv"
+
+func StringToInt64(number string) (int64, error) {
+	i, err := strconv.ParseInt(number, 10, 64)
+	if err != nil {
+		return -1, err
+	}
+	return i, nil
+}
+
+func Int64ToString(number int64) string {
+	convedNumber := strconv.FormatInt(number, 10)
+	return convedNumber
+}

mod/disk/sortfile/common.go

@@ -1,15 +1,15 @@
 package sortfile
 
 import (
-	"os"
-    "log"
+	"bufio"
+	"encoding/base64"
+	"errors"
+	"io/ioutil"
+	"log"
 	"net/http"
+	"os"
 	"strconv"
 	"strings"
-	"errors"
-	"encoding/base64"
-	"bufio"
-	"io/ioutil"
 	"time"
 )
 
@@ -48,6 +48,7 @@ func sendOK(w http.ResponseWriter) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Write([]byte("\"OK\""))
 }
+
 /*
 	The paramter move function (mv)
 
@@ -87,136 +88,134 @@ func mv(r *http.Request, getParamter string, postMode bool) (string, error) {
 }
 
 func stringInSlice(a string, list []string) bool {
-    for _, b := range list {
-        if b == a {
-            return true
-        }
-    }
-    return false
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
 }
 
-
 func fileExists(filename string) bool {
-    _, err := os.Stat(filename)
-    if os.IsNotExist(err) {
-        return false
-    }
-    return true
+	_, err := os.Stat(filename)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return true
 }
 
-
-func IsDir(path string) bool{
-	if (fileExists(path) == false){
+func IsDir(path string) bool {
+	if fileExists(path) == false {
 		return false
 	}
 	fi, err := os.Stat(path)
-    if err != nil {
-        log.Fatal(err)
-        return false
-    }
-    switch mode := fi.Mode(); {
-    case mode.IsDir():
-        return true
-    case mode.IsRegular():
-        return false
+	if err != nil {
+		log.Fatal(err)
+		return false
+	}
+	switch mode := fi.Mode(); {
+	case mode.IsDir():
+		return true
+	case mode.IsRegular():
+		return false
 	}
 	return false
 }
 
 func inArray(arr []string, str string) bool {
 	for _, a := range arr {
-	   if a == str {
-		  return true
-	   }
+		if a == str {
+			return true
+		}
 	}
 	return false
- }
+}
 
- func timeToString(targetTime time.Time) string{
-	 return targetTime.Format("2006-01-02 15:04:05")
- }
+func timeToString(targetTime time.Time) string {
+	return targetTime.Format("2006-01-02 15:04:05")
+}
 
- func IntToString(number int) string{
+func IntToString(number int) string {
 	return strconv.Itoa(number)
- }
+}
 
- func StringToInt(number string) (int, error){
+func StringToInt(number string) (int, error) {
 	return strconv.Atoi(number)
- }
+}
 
- func StringToInt64(number string) (int64, error){
+func StringToInt64(number string) (int64, error) {
 	i, err := strconv.ParseInt(number, 10, 64)
 	if err != nil {
 		return -1, err
 	}
 	return i, nil
- }
+}
 
- func Int64ToString(number int64) string{
-	convedNumber:=strconv.FormatInt(number,10)
+func Int64ToString(number int64) string {
+	convedNumber := strconv.FormatInt(number, 10)
 	return convedNumber
- }
+}
 
- func GetUnixTime() int64{
+func GetUnixTime() int64 {
 	return time.Now().Unix()
- }
+}
 
- func LoadImageAsBase64(filepath string) (string, error){
-	if !fileExists(filepath){
+func LoadImageAsBase64(filepath string) (string, error) {
+	if !fileExists(filepath) {
 		return "", errors.New("File not exists")
 	}
 	f, _ := os.Open(filepath)
-    reader := bufio.NewReader(f)
-    content, _ := ioutil.ReadAll(reader)
+	reader := bufio.NewReader(f)
+	content, _ := ioutil.ReadAll(reader)
 	encoded := base64.StdEncoding.EncodeToString(content)
 	return string(encoded), nil
- }
+}
 
- func PushToSliceIfNotExist(slice []string, newItem string) []string {
+func PushToSliceIfNotExist(slice []string, newItem string) []string {
 	itemExists := false
-	for _, item := range slice{
-		if item == newItem{
+	for _, item := range slice {
+		if item == newItem {
 			itemExists = true
 		}
 	}
 
-	if !itemExists{
+	if !itemExists {
 		slice = append(slice, newItem)
 	}
 
 	return slice
- }
+}
 
- func RemoveFromSliceIfExists(slice []string, target string) []string {
-	 newSlice := []string{}
-	 for _, item := range slice{
-		 if item != target{
+func RemoveFromSliceIfExists(slice []string, target string) []string {
+	newSlice := []string{}
+	for _, item := range slice {
+		if item != target {
 			newSlice = append(newSlice, item)
-		 }
-	 }
+		}
+	}
 
-	 return newSlice;
- }
+	return newSlice
+}
 
- //Get the IP address of the current authentication user
+//Get the IP address of the current authentication user
 func ReflectUserIP(w http.ResponseWriter, r *http.Request) {
-    requestPort,_ :=  mv(r, "port", false)
-    showPort := false;
-    if (requestPort == "true"){
-        //Show port as well
-        showPort = true;
-    }
-    IPAddress := r.Header.Get("X-Real-Ip")
-    if IPAddress == "" {
-        IPAddress = r.Header.Get("X-Forwarded-For")
-    }
-    if IPAddress == "" {
-        IPAddress = r.RemoteAddr
-    }
-    if (!showPort){
-        IPAddress = IPAddress[:strings.LastIndex(IPAddress, ":")]
-
-    }
-    w.Write([]byte(IPAddress))
-    return;
-}
+	requestPort, _ := mv(r, "port", false)
+	showPort := false
+	if requestPort == "true" {
+		//Show port as well
+		showPort = true
+	}
+	IPAddress := r.Header.Get("X-Real-Ip")
+	if IPAddress == "" {
+		IPAddress = r.Header.Get("X-Forwarded-For")
+	}
+	if IPAddress == "" {
+		IPAddress = r.RemoteAddr
+	}
+	if !showPort {
+		IPAddress = IPAddress[:strings.LastIndex(IPAddress, ":")]
+
+	}
+	w.Write([]byte(IPAddress))
+	return
+}

module.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"os"
 
+	"imuslab.com/arozos/mod/common"
 	module "imuslab.com/arozos/mod/modules"
 	prout "imuslab.com/arozos/mod/prouter"
 )
@@ -39,7 +40,7 @@ func ModuleServiceInit() {
 
 	adminRouter.HandleFunc("/system/modules/reload", func(w http.ResponseWriter, r *http.Request) {
 		moduleHandler.ReloadAllModules(AGIGateway)
-		sendOK(w)
+		common.SendOK(w)
 	})
 
 	//Handle module installer. Require admin
@@ -47,16 +48,16 @@ func ModuleServiceInit() {
 		//Check if the user is admin
 		userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 		if err != nil {
-			sendErrorResponse(w, "User not logged in")
+			common.SendErrorResponse(w, "User not logged in")
 			return
 		}
 
 		//Validate the user is admin
 		if userinfo.IsAdmin() {
 			//Get the installation file path
-			installerPath, err := mv(r, "path", true)
+			installerPath, err := common.Mv(r, "path", true)
 			if err != nil {
-				sendErrorResponse(w, "Invalid installer path")
+				common.SendErrorResponse(w, "Invalid installer path")
 				return
 			}
 
@@ -64,7 +65,7 @@ func ModuleServiceInit() {
 			rpath, err := userinfo.VirtualPathToRealPath(installerPath)
 			if err != nil {
 				log.Println("*Module Installer* Failed to install module: ", err.Error())
-				sendErrorResponse(w, "Invalid installer path")
+				common.SendErrorResponse(w, "Invalid installer path")
 				return
 			}
 
@@ -72,7 +73,7 @@ func ModuleServiceInit() {
 			moduleHandler.InstallViaZip(rpath, AGIGateway)
 		} else {
 			//Permission denied
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		}
 
 	})
@@ -144,44 +145,44 @@ func ModuleInstallerInit() {
 
 //Handle module installation request
 func HandleModuleInstall(w http.ResponseWriter, r *http.Request) {
-	opr, _ := mv(r, "opr", true)
+	opr, _ := common.Mv(r, "opr", true)
 
 	if opr == "gitinstall" {
 		//Get URL from request
-		url, _ := mv(r, "url", true)
+		url, _ := common.Mv(r, "url", true)
 		if url == "" {
-			sendErrorResponse(w, "Invalid URL")
+			common.SendErrorResponse(w, "Invalid URL")
 			return
 		}
 
 		//Install the module using git
 		err := moduleHandler.InstallModuleViaGit(url, AGIGateway)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
 		//Reply ok
-		sendOK(w)
+		common.SendOK(w)
 	} else if opr == "zipinstall" {
 
 	} else if opr == "remove" {
 		//Get the module name from list
-		module, _ := mv(r, "module", true)
+		module, _ := common.Mv(r, "module", true)
 		if module == "" {
-			sendErrorResponse(w, "Invalid Module Name")
+			common.SendErrorResponse(w, "Invalid Module Name")
 			return
 		}
 
 		//Remove the module
 		err := moduleHandler.UninstallModule(module)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
 		//Reply ok
-		sendOK(w)
+		common.SendOK(w)
 
 	} else {
 		//List all the modules

network.forward.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"strconv"
 
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 )
 
@@ -46,7 +47,7 @@ func portForwardInit() {
 			AdminOnly:   false,
 			UserHandler: userHandler,
 			DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-				sendErrorResponse(w, "Permission Denied")
+				common.SendErrorResponse(w, "Permission Denied")
 			},
 		})
 
@@ -63,10 +64,10 @@ func portForwardInit() {
 }
 
 func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
-	opr, _ := mv(r, "opr", true)
+	opr, _ := common.Mv(r, "opr", true)
 	if opr == "" {
 		if UPNP == nil {
-			sendErrorResponse(w, "UPNP is not enabled")
+			common.SendErrorResponse(w, "UPNP is not enabled")
 			return
 		}
 		//List the current forward port and names
@@ -101,23 +102,23 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 
 		//Send the result as json
 		js, _ := json.Marshal(forwardPorts)
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 	} else if opr == "add" {
-		port, err := mv(r, "port", true)
+		port, err := common.Mv(r, "port", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid port number")
+			common.SendErrorResponse(w, "Invalid port number")
 			return
 		}
 
 		//Convert port to int
 		portNumberic, err := strconv.Atoi(port)
 		if err != nil {
-			sendErrorResponse(w, "Invalid port number")
+			common.SendErrorResponse(w, "Invalid port number")
 			return
 		}
 
 		//Get the policy name
-		policyName, err := mv(r, "name", true)
+		policyName, err := common.Mv(r, "name", true)
 		if err != nil {
 			policyName = "Unnamed Forward Policy"
 		}
@@ -129,25 +130,25 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 			//Forward the port
 			err := UPNP.ForwardPort(portNumberic, policyName)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 			} else {
-				sendOK(w)
+				common.SendOK(w)
 			}
 		} else {
-			sendErrorResponse(w, "UPNP is not enabled")
+			common.SendErrorResponse(w, "UPNP is not enabled")
 			return
 		}
 	} else if opr == "remove" {
-		port, err := mv(r, "port", true)
+		port, err := common.Mv(r, "port", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid port number")
+			common.SendErrorResponse(w, "Invalid port number")
 			return
 		}
 
 		//Convert port to int
 		portNumberic, err := strconv.Atoi(port)
 		if err != nil {
-			sendErrorResponse(w, "Invalid port number")
+			common.SendErrorResponse(w, "Invalid port number")
 			return
 		}
 
@@ -160,12 +161,12 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 		if UPNP != nil {
 			err := UPNP.ClosePort(portNumberic)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 			} else {
-				sendOK(w)
+				common.SendOK(w)
 			}
 		} else {
-			sendErrorResponse(w, "UPNP is not enabled")
+			common.SendErrorResponse(w, "UPNP is not enabled")
 			return
 		}
 	}

network.ftp.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"strconv"
 
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 	ftp "imuslab.com/arozos/mod/storage/ftp"
 )
@@ -72,17 +73,17 @@ func FTPServerInit() {
 	set=mode&passive=true
 */
 func storageHandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Request) {
-	set, err := mv(r, "set", true)
+	set, err := common.Mv(r, "set", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid set type")
+		common.SendErrorResponse(w, "Invalid set type")
 		return
 	}
 
 	if set == "ip" {
 		//Updat the public up addr
-		ip, err := mv(r, "ip", true)
+		ip, err := common.Mv(r, "ip", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid ip given")
+			common.SendErrorResponse(w, "Invalid ip given")
 			return
 		}
 
@@ -90,9 +91,9 @@ func storageHandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Request)
 
 	} else if set == "mode" {
 		//Update the passive mode setting
-		passive, err := mv(r, "passive", true)
+		passive, err := common.Mv(r, "passive", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid passive option (true/false)")
+			common.SendErrorResponse(w, "Invalid passive option (true/false)")
 			return
 		}
 
@@ -103,7 +104,7 @@ func storageHandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Request)
 			sysdb.Write("ftp", "passive", false)
 		}
 	} else {
-		sendErrorResponse(w, "Unknown setting filed")
+		common.SendErrorResponse(w, "Unknown setting filed")
 		return
 	}
 
@@ -118,12 +119,12 @@ func storageHandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Request)
 func storageHandleFTPServerStart(w http.ResponseWriter, r *http.Request) {
 	err := storageFTPServerStart()
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 	}
 
 	//Remember the FTP server status
 	sysdb.Write("ftp", "default", true)
-	sendOK(w)
+	common.SendOK(w)
 }
 
 //Stop the FTP server by request
@@ -133,12 +134,12 @@ func storageHandleFTPServerStop(w http.ResponseWriter, r *http.Request) {
 	}
 	sysdb.Write("ftp", "default", false)
 	log.Println("FTP Server Stopped")
-	sendOK(w)
+	common.SendOK(w)
 }
 
 //Update UPnP setting on FTP server
 func storageHandleFTPuPnP(w http.ResponseWriter, r *http.Request) {
-	enable, _ := mv(r, "enable", false)
+	enable, _ := common.Mv(r, "enable", false)
 	if enable == "true" {
 		log.Println("Enabling UPnP on FTP Server Port")
 		sysdb.Write("ftp", "upnp", true)
@@ -152,15 +153,15 @@ func storageHandleFTPuPnP(w http.ResponseWriter, r *http.Request) {
 		storageFTPServerStart()
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 //Update access permission on FTP server
 func storageHandleFTPAccessUpdate(w http.ResponseWriter, r *http.Request) {
 	//Get groups paramter from post req
-	groupString, err := mv(r, "groups", true)
+	groupString, err := common.Mv(r, "groups", true)
 	if err != nil {
-		sendErrorResponse(w, "groups not defined")
+		common.SendErrorResponse(w, "groups not defined")
 		return
 	}
 
@@ -168,7 +169,7 @@ func storageHandleFTPAccessUpdate(w http.ResponseWriter, r *http.Request) {
 	groups := []string{}
 	err = json.Unmarshal([]byte(groupString), &groups)
 	if err != nil {
-		sendErrorResponse(w, "Unable to parse groups")
+		common.SendErrorResponse(w, "Unable to parse groups")
 		return
 	}
 
@@ -176,20 +177,20 @@ func storageHandleFTPAccessUpdate(w http.ResponseWriter, r *http.Request) {
 	//Set the accessable group
 	ftp.UpdateAccessableGroups(sysdb, groups)
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func storageHandleFTPSetPort(w http.ResponseWriter, r *http.Request) {
-	port, err := mv(r, "port", true)
+	port, err := common.Mv(r, "port", true)
 	if err != nil {
-		sendErrorResponse(w, "Port not defined")
+		common.SendErrorResponse(w, "Port not defined")
 		return
 	}
 
 	//Try parse the port into int
 	portInt, err := strconv.Atoi(port)
 	if err != nil {
-		sendErrorResponse(w, "Invalid port number")
+		common.SendErrorResponse(w, "Invalid port number")
 		return
 	}
 
@@ -199,7 +200,7 @@ func storageHandleFTPSetPort(w http.ResponseWriter, r *http.Request) {
 	//Restart the FTP server
 	storageFTPServerStart()
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func storageHandleFTPServerStatus(w http.ResponseWriter, r *http.Request) {
@@ -280,7 +281,7 @@ func storageHandleFTPServerStatus(w http.ResponseWriter, r *http.Request) {
 		UserGroups:     userGroups,
 		PassiveMode:    forcePassiveMode,
 	})
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func storageFTPServerStart() error {

network.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"strconv"
 
+	"imuslab.com/arozos/mod/common"
 	network "imuslab.com/arozos/mod/network"
 	mdns "imuslab.com/arozos/mod/network/mdns"
 	"imuslab.com/arozos/mod/network/netstat"
@@ -29,7 +30,7 @@ func NetworkServiceInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 

network.webdav.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 	awebdav "imuslab.com/arozos/mod/storage/webdav"
 )
@@ -48,7 +49,7 @@ func WebDAVInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -60,22 +61,22 @@ func WebDAVInit() {
 		userinfo, _ := userHandler.GetUserInfoFromRequest(w, r)
 		isAdmin := userinfo.IsAdmin()
 
-		set, _ := mv(r, "set", false)
+		set, _ := common.Mv(r, "set", false)
 		if set == "" {
 			//Return the current status
 			results := []bool{WebDavHandler.Enabled, isAdmin}
 			js, _ := json.Marshal(results)
-			sendJSONResponse(w, string(js))
+			common.SendJSONResponse(w, string(js))
 		} else if isAdmin && set == "disable" {
 			WebDavHandler.Enabled = false
 			sysdb.Write("webdav", "enabled", false)
-			sendOK(w)
+			common.SendOK(w)
 		} else if isAdmin && set == "enable" {
 			WebDavHandler.Enabled = true
 			sysdb.Write("webdav", "enabled", true)
-			sendOK(w)
+			common.SendOK(w)
 		} else {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		}
 	})
 

notification.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"time"
 
+	fs "imuslab.com/arozos/mod/filesystem"
 	notification "imuslab.com/arozos/mod/notification"
 	"imuslab.com/arozos/mod/notification/agents/smtpn"
 )
@@ -32,7 +33,7 @@ func notificationInit() {
 	}
 
 	smtpnConfigPath := "./system/smtp_conf.json"
-	if !fileExists(smtpnConfigPath) {
+	if !fs.FileExists(smtpnConfigPath) {
 		//Create an empty one
 		smtpn.GenerateEmptyConfigFile(smtpnConfigPath)
 	}

permission.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	permission "imuslab.com/arozos/mod/permission"
 	prout "imuslab.com/arozos/mod/prouter"
 )
@@ -27,7 +28,7 @@ func permissionInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -36,7 +37,7 @@ func permissionInit() {
 		if authAgent.GetUserCounts() == 0 {
 			//There is no user within the system. Only allow register of admin account
 			js, _ := json.Marshal([]string{"administrator"})
-			sendJSONResponse(w, string(js))
+			common.SendJSONResponse(w, string(js))
 			//permissionHandler.HandleListGroup(w, r)
 		} else {
 			//There are already users in the system. Only allow authorized users

quota.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"
 
+	"imuslab.com/arozos/mod/common"
 	fs "imuslab.com/arozos/mod/filesystem"
 	//user "imuslab.com/arozos/mod/user"
 )
@@ -46,45 +47,45 @@ func system_disk_quota_updateAllUserQuotaEstimation() {
 func system_disk_quota_setQuota(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Unknown User")
+		common.SendErrorResponse(w, "Unknown User")
 		return
 	}
 
 	//Check if admin
 	if !userinfo.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
-	groupname, err := mv(r, "groupname", true)
+	groupname, err := common.Mv(r, "groupname", true)
 	if err != nil {
-		sendErrorResponse(w, "Group name not defned")
+		common.SendErrorResponse(w, "Group name not defned")
 		return
 	}
 
-	quotaSizeString, err := mv(r, "quota", true)
+	quotaSizeString, err := common.Mv(r, "quota", true)
 	if err != nil {
-		sendErrorResponse(w, "Quota not defined")
+		common.SendErrorResponse(w, "Quota not defined")
 		return
 	}
 
-	quotaSize, err := StringToInt64(quotaSizeString)
+	quotaSize, err := common.StringToInt64(quotaSizeString)
 	if err != nil || quotaSize < 0 {
-		sendErrorResponse(w, "Invalid quota size given")
+		common.SendErrorResponse(w, "Invalid quota size given")
 		return
 	}
 	//Qutasize unit is in MB
 	quotaSize = quotaSize << 20
 
 	log.Println("Updating "+groupname+" to ", quotaSize, "WIP")
-	sendOK(w)
+	common.SendOK(w)
 
 }
 
 func system_disk_quota_handleQuotaInfo(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Unknown User")
+		common.SendErrorResponse(w, "Unknown User")
 		return
 	}
 
@@ -101,7 +102,7 @@ func system_disk_quota_handleQuotaInfo(w http.ResponseWriter, r *http.Request) {
 		Total:     userinfo.StorageQuota.TotalStorageQuota,
 	})
 
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 
 	go func() {
 		//Update this user's quota estimation in go routine
@@ -113,7 +114,7 @@ func system_disk_quota_handleQuotaInfo(w http.ResponseWriter, r *http.Request) {
 func system_disk_quota_handleFileDistributionView(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Unknown User")
+		common.SendErrorResponse(w, "Unknown User")
 		return
 	}
 
@@ -157,5 +158,5 @@ func system_disk_quota_handleFileDistributionView(w http.ResponseWriter, r *http
 
 	//Return the distrubution using json string
 	jsonString, _ := json.Marshal(ss)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }

register.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 
 	reg "imuslab.com/arozos/mod/auth/register"
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 )
 
@@ -38,7 +39,7 @@ func RegisterSystemInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -61,7 +62,7 @@ func RegisterSystemInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -84,14 +85,14 @@ func RegisterSystemInit() {
 func register_handleRegisterCleaning(w http.ResponseWriter, r *http.Request) {
 	//Get all user emails from the registerHandler
 	registerHandler.CleanRegisters()
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func register_handleEmailListing(w http.ResponseWriter, r *http.Request) {
 	//Get all user emails from the registerHandler
 	userRegisterInfos := registerHandler.ListAllUserEmails()
 
-	useCSV, _ := mv(r, "csv", false)
+	useCSV, _ := common.Mv(r, "csv", false)
 	if useCSV == "true" {
 		//Prase as csv
 		csvString := "Username,Email,Still Registered\n"
@@ -110,41 +111,41 @@ func register_handleEmailListing(w http.ResponseWriter, r *http.Request) {
 	} else {
 		//Prase as json
 		jsonString, _ := json.Marshal(userRegisterInfos)
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 	}
 
 }
 
 func register_handleSetDefaultGroup(w http.ResponseWriter, r *http.Request) {
-	getDefaultGroup, _ := mv(r, "get", true)
+	getDefaultGroup, _ := common.Mv(r, "get", true)
 	if getDefaultGroup == "true" {
 		jsonString, _ := json.Marshal(registerHandler.DefaultUserGroup)
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 		return
 	}
-	newDefaultGroup, err := mv(r, "defaultGroup", true)
+	newDefaultGroup, err := common.Mv(r, "defaultGroup", true)
 	if err != nil {
-		sendErrorResponse(w, "defaultGroup not defined")
+		common.SendErrorResponse(w, "defaultGroup not defined")
 		return
 	}
 	err = registerHandler.SetDefaultUserGroup(newDefaultGroup)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func register_handleGetAllowRegistry(w http.ResponseWriter, r *http.Request) {
 	jsonString, _ := json.Marshal(registerHandler.AllowRegistry)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func register_handleToggleRegistry(w http.ResponseWriter, r *http.Request) {
-	allowReg, err := mv(r, "allow", true)
+	allowReg, err := common.Mv(r, "allow", true)
 	if err != nil {
 		allowReg = "false"
 	}
 	registerHandler.SetAllowRegistry(allowReg == "true")
-	sendOK(w)
+	common.SendOK(w)
 }

scheduler.go

@@ -4,6 +4,7 @@ import (
 	"log"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	module "imuslab.com/arozos/mod/modules"
 	prout "imuslab.com/arozos/mod/prouter"
 	"imuslab.com/arozos/mod/time/nightly"
@@ -47,7 +48,7 @@ func SchedulerInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 

security.go

@@ -4,6 +4,7 @@ import (
 	"net/http"
 	"time"
 
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 	"imuslab.com/arozos/mod/security/csrf"
 )
@@ -30,7 +31,7 @@ func security_init() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 

setting.advance.go

@@ -4,6 +4,7 @@ import (
 	"net/http"
 
 	autologin "imuslab.com/arozos/mod/auth/autologin"
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 )
 
@@ -24,7 +25,7 @@ func AdvanceSettingInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 

setting.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	module "imuslab.com/arozos/mod/modules"
 )
 
@@ -121,12 +122,12 @@ func registerSetting(thismodule settingModule) {
 func system_setting_handleListing(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	allSettingGroups := system_setting_getSettingGroups()
-	listGroup, _ := mv(r, "listGroup", false)
+	listGroup, _ := common.Mv(r, "listGroup", false)
 	if len(listGroup) > 0 {
 		//List the given group
 		var results []settingModule
@@ -146,18 +147,18 @@ func system_setting_handleListing(w http.ResponseWriter, r *http.Request) {
 
 		if len(results) > 0 {
 			jsonString, _ := json.Marshal(results)
-			sendJSONResponse(w, string(jsonString))
+			common.SendJSONResponse(w, string(jsonString))
 			return
 		} else {
 			//This group not found,
-			sendErrorResponse(w, "Group not found")
+			common.SendErrorResponse(w, "Group not found")
 			return
 		}
 
 	} else {
 		//List all root groups
 		jsonString, _ := json.Marshal(allSettingGroups)
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 		return
 	}
 

startup.flags.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"net/http"
 
+	"imuslab.com/arozos/mod/common"
 	prout "imuslab.com/arozos/mod/prouter"
 )
 
@@ -32,7 +33,7 @@ func StartupFlagsInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -49,7 +50,7 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 		EnableHomePage    bool
 		EnableDirListing  bool
 	}
-	opr, _ := mv(r, "opr", true)
+	opr, _ := common.Mv(r, "opr", true)
 	if opr == "" {
 		//List the current boot flag, all units in MB
 		js, _ := json.Marshal(bootFlags{
@@ -62,12 +63,12 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 			*enable_dir_listing,
 		})
 
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 	} else if opr == "set" {
 		//Set and update the boot flags
-		newSettings, err := mv(r, "value", true)
+		newSettings, err := common.Mv(r, "value", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid new seting value")
+			common.SendErrorResponse(w, "Invalid new seting value")
 			return
 		}
 
@@ -83,7 +84,7 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 		}
 		err = json.Unmarshal([]byte(newSettings), &newConfig)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
@@ -97,8 +98,8 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 		*allow_homepage = newConfig.EnableHomePage
 		*enable_dir_listing = newConfig.EnableDirListing
 
-		sendOK(w)
+		common.SendOK(w)
 	} else {
-		sendErrorResponse(w, "Unknown operation")
+		common.SendErrorResponse(w, "Unknown operation")
 	}
 }

startup.go

@@ -12,13 +12,14 @@ import (
 
 	db "imuslab.com/arozos/mod/database"
 	"imuslab.com/arozos/mod/filesystem"
+	fs "imuslab.com/arozos/mod/filesystem"
 )
 
 func RunStartup() {
 	//1. Initiate the main system database
 
 	//Check if system or web both not exists and web.tar.gz exists. Unzip it for the user
-	if (!fileExists("system/") || !fileExists("web/")) && fileExists("./web.tar.gz") {
+	if (!fs.FileExists("system/") || !fs.FileExists("web/")) && fs.FileExists("./web.tar.gz") {
 		log.Println("Unzipping system critical files from archive")
 		extErr := filesystem.ExtractTarGzipFile("./web.tar.gz", "./")
 		if extErr != nil {
@@ -35,12 +36,12 @@ func RunStartup() {
 		}
 	}
 
-	if !fileExists("system/") {
+	if !fs.FileExists("system/") {
 		fmt.Println("▒▒ ERROR: SYSTEM FOLDER NOT FOUND ▒▒")
 		panic("This error occurs because the system folder is missing. Please follow the installation guide and don't just download a binary and run it.")
 	}
 
-	if !fileExists("web/") {
+	if !fs.FileExists("web/") {
 		fmt.Println("▒▒ ERROR: WEB FOLDER NOT FOUND ▒▒")
 		panic("This error occurs because the web folder is missing. Please follow the installation guide and don't just download a binary and run it.")
 	}

storage.go

@@ -25,7 +25,7 @@ var (
 
 func StorageInit() {
 	//Load the default handler for the user storage root
-	if !fileExists(filepath.Clean(*root_directory) + "/") {
+	if !fs.FileExists(filepath.Clean(*root_directory) + "/") {
 		os.MkdirAll(filepath.Clean(*root_directory)+"/", 0755)
 	}
 
@@ -148,7 +148,7 @@ func GroupStoragePoolInit() {
 
 func LoadStoragePoolForGroup(pg *permission.PermissionGroup) error {
 	expectedConfigPath := "./system/storage/" + pg.Name + ".json"
-	if fileExists(expectedConfigPath) {
+	if fs.FileExists(expectedConfigPath) {
 		//Read the config file
 		pgStorageConfig, err := ioutil.ReadFile(expectedConfigPath)
 		if err != nil {

storage.pool.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"
 
+	"imuslab.com/arozos/mod/common"
 	"imuslab.com/arozos/mod/database"
 	"imuslab.com/arozos/mod/permission"
 	"imuslab.com/arozos/mod/storage/bridge"
@@ -36,7 +37,7 @@ func StoragePoolEditorInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -53,17 +54,17 @@ func StoragePoolEditorInit() {
 
 //Handle editing of a given File System Handler
 func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
-	opr, _ := mv(r, "opr", false)
+	opr, _ := common.Mv(r, "opr", false)
 
-	uuid, err := mv(r, "uuid", false)
+	uuid, err := common.Mv(r, "uuid", false)
 	if err != nil {
-		sendErrorResponse(w, "Invalid UUID")
+		common.SendErrorResponse(w, "Invalid UUID")
 		return
 	}
 
-	group, err := mv(r, "group", false)
+	group, err := common.Mv(r, "group", false)
 	if err != nil {
-		sendErrorResponse(w, "Invalid group given")
+		common.SendErrorResponse(w, "Invalid group given")
 		return
 	}
 
@@ -71,7 +72,7 @@ func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
 		//Load
 		fshOption, err := getFSHConfigFromGroupAndUUID(group, uuid)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 		//Hide the password info
@@ -80,7 +81,7 @@ func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
 
 		//Return as JSON
 		js, _ := json.Marshal(fshOption)
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 		return
 	} else if opr == "set" {
 		//Set
@@ -98,7 +99,7 @@ func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
 
 	} else {
 		//Unknown
-		sendErrorResponse(w, "Unknown opr given")
+		common.SendErrorResponse(w, "Unknown opr given")
 		return
 	}
 }
@@ -114,12 +115,12 @@ func getFSHConfigFromGroupAndUUID(group string, uuid string) (*fs.FileSystemOpti
 	}
 
 	//Check if file exists.
-	if !fileExists(targerFile) {
+	if !fs.FileExists(targerFile) {
 		log.Println("Config file not found: ", targerFile)
 		return nil, errors.New("Configuration file not found")
 	}
 
-	if !fileExists(filepath.Dir(targerFile)) {
+	if !fs.FileExists(filepath.Dir(targerFile)) {
 		os.MkdirAll(filepath.Dir(targerFile), 0775)
 	}
 
@@ -157,12 +158,12 @@ func setFSHConfigByGroupAndId(group string, uuid string, options fs.FileSystemOp
 	}
 
 	//Check if file exists.
-	if !fileExists(targerFile) {
+	if !fs.FileExists(targerFile) {
 		log.Println("Config file not found: ", targerFile)
 		return errors.New("Configuration file not found")
 	}
 
-	if !fileExists(filepath.Dir(targerFile)) {
+	if !fs.FileExists(filepath.Dir(targerFile)) {
 		os.MkdirAll(filepath.Dir(targerFile), 0775)
 	}
 
@@ -197,27 +198,27 @@ func setFSHConfigByGroupAndId(group string, uuid string, options fs.FileSystemOp
 
 //Handle Storage Pool toggle on-off
 func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
-	fsh, _ := mv(r, "fsh", true)
+	fsh, _ := common.Mv(r, "fsh", true)
 	if fsh == "" {
-		sendErrorResponse(w, "Invalid File System Handler ID")
+		common.SendErrorResponse(w, "Invalid File System Handler ID")
 		return
 	}
 
-	group, _ := mv(r, "group", true)
+	group, _ := common.Mv(r, "group", true)
 	if group == "" {
-		sendErrorResponse(w, "Invalid group ID")
+		common.SendErrorResponse(w, "Invalid group ID")
 		return
 	}
 
 	//Check if group exists
 	if group != "system" && !permissionHandler.GroupExists(group) {
-		sendErrorResponse(w, "Group not exists")
+		common.SendErrorResponse(w, "Group not exists")
 		return
 	}
 
 	//Not allow to modify system reserved fsh
 	if fsh == "user" || fsh == "tmp" {
-		sendErrorResponse(w, "Cannot toggle system reserved File System Handler")
+		common.SendErrorResponse(w, "Cannot toggle system reserved File System Handler")
 		return
 	}
 
@@ -241,7 +242,7 @@ func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
 
 	//Target File System Handler not found
 	if targetFSH == nil {
-		sendErrorResponse(w, "Target File System Handler not found, given: "+fsh)
+		common.SendErrorResponse(w, "Target File System Handler not found, given: "+fsh)
 		return
 	}
 
@@ -250,7 +251,7 @@ func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
 		aofsPath := filepath.ToSlash(filepath.Clean(targetFSH.Path)) + "/aofs.db"
 		conn, err := database.NewDatabase(aofsPath, false)
 		if err != nil {
-			sendErrorResponse(w, "Filesystme database startup failed")
+			common.SendErrorResponse(w, "Filesystme database startup failed")
 			return
 		}
 
@@ -266,13 +267,13 @@ func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
 	time.Sleep(1 * time.Second)
 
 	//Return ok
-	sendOK(w)
+	common.SendOK(w)
 
 }
 
 //Handle reload of storage pool
 func HandleStoragePoolReload(w http.ResponseWriter, r *http.Request) {
-	pool, _ := mv(r, "pool", true)
+	pool, _ := common.Mv(r, "pool", true)
 
 	//Basepool super long string just to prevent any typo
 	if pool == "1eb201a3-d0f6-6630-5e6d-2f40480115c5" {
@@ -333,7 +334,7 @@ func HandleStoragePoolReload(w http.ResponseWriter, r *http.Request) {
 		} else {
 			//Reload the given storage pool
 			if !permissionHandler.GroupExists(pool) {
-				sendErrorResponse(w, "Permission Pool owner not exists")
+				common.SendErrorResponse(w, "Permission Pool owner not exists")
 				return
 			}
 
@@ -355,38 +356,38 @@ func HandleStoragePoolReload(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func HandleStoragePoolRemove(w http.ResponseWriter, r *http.Request) {
-	groupname, err := mv(r, "group", true)
+	groupname, err := common.Mv(r, "group", true)
 	if err != nil {
-		sendErrorResponse(w, "group not defined")
+		common.SendErrorResponse(w, "group not defined")
 		return
 	}
 
-	uuid, err := mv(r, "uuid", true)
+	uuid, err := common.Mv(r, "uuid", true)
 	if err != nil {
-		sendErrorResponse(w, "File system handler UUID not defined")
+		common.SendErrorResponse(w, "File system handler UUID not defined")
 		return
 	}
 
 	targetConfigFile := "./system/storage.json"
 	if groupname == "system" {
 		if uuid == "user" || uuid == "tmp" {
-			sendErrorResponse(w, "Cannot remove system reserved file system handlers")
+			common.SendErrorResponse(w, "Cannot remove system reserved file system handlers")
 			return
 		}
 		//Ok to continue
 	} else {
 		//Check group exists
 		if !permissionHandler.GroupExists(groupname) {
-			sendErrorResponse(w, "Group not exists")
+			common.SendErrorResponse(w, "Group not exists")
 			return
 		}
 
 		targetConfigFile = "./system/storage/" + groupname + ".json"
-		if !fileExists(targetConfigFile) {
+		if !fs.FileExists(targetConfigFile) {
 			//No config. Create an empty one
 			initConfig := []fs.FileSystemOption{}
 			js, _ := json.MarshalIndent(initConfig, "", " ")
@@ -400,18 +401,18 @@ func HandleStoragePoolRemove(w http.ResponseWriter, r *http.Request) {
 		//Bridged FSH. Remove it from bridge config
 		basePool, err := GetStoragePoolByOwner(groupname)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 		err = DebridgeFSHandlerFromGroup(uuid, basePool)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
 		//Remove it from the config
 		bridgeManager.RemoveFromConfig(uuid, groupname)
-		sendOK(w)
+		common.SendOK(w)
 		return
 	} else {
 		//Remove it from the json file
@@ -420,7 +421,7 @@ func HandleStoragePoolRemove(w http.ResponseWriter, r *http.Request) {
 		originalConfigFile, _ := ioutil.ReadFile(targetConfigFile)
 		err = json.Unmarshal(originalConfigFile, &oldConfigs)
 		if err != nil {
-			sendErrorResponse(w, "Failed to parse original config file")
+			common.SendErrorResponse(w, "Failed to parse original config file")
 			return
 		}
 
@@ -442,7 +443,7 @@ func HandleStoragePoolRemove(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 }
 
 //Constract a fsoption from form
@@ -510,7 +511,7 @@ func HandleStorageNewFsHandler(w http.ResponseWriter, r *http.Request) {
 
 	//If file exists, merge it to
 	oldConfigs := []fs.FileSystemOption{}
-	if fileExists(configFile) {
+	if fs.FileExists(configFile) {
 		originalConfigFile, _ := ioutil.ReadFile(configFile)
 		err := json.Unmarshal(originalConfigFile, &oldConfigs)
 		if err != nil {
@@ -539,7 +540,7 @@ func HandleStorageNewFsHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 func HandleListStoragePoolsConfig(w http.ResponseWriter, r *http.Request) {
-	target, _ := mv(r, "target", false)
+	target, _ := common.Mv(r, "target", false)
 	if target == "" {
 		target = "system"
 	}
@@ -552,27 +553,27 @@ func HandleListStoragePoolsConfig(w http.ResponseWriter, r *http.Request) {
 		targetFile = "./system/storage/" + target + ".json"
 	}
 
-	if !fileExists(targetFile) {
+	if !fs.FileExists(targetFile) {
 		//Assume no storage.
 		nofsh := []*fs.FileSystemOption{}
 		js, _ := json.Marshal(nofsh)
-		sendJSONResponse(w, string(js))
+		common.SendJSONResponse(w, string(js))
 		return
 	}
 
 	//Read and serve it
 	configContent, err := ioutil.ReadFile(targetFile)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	} else {
-		sendJSONResponse(w, string(configContent))
+		common.SendJSONResponse(w, string(configContent))
 	}
 }
 
 //Return all storage pool mounted to the system, aka base pool + pg pools
 func HandleListStoragePools(w http.ResponseWriter, r *http.Request) {
-	filter, _ := mv(r, "filter", false)
+	filter, _ := common.Mv(r, "filter", false)
 
 	storagePools := []*storage.StoragePool{}
 
@@ -597,15 +598,15 @@ func HandleListStoragePools(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(storagePools)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 //Handler for bridging two FSH, require admin permission
 func HandleFSHBridging(w http.ResponseWriter, r *http.Request) {
 	//Get the target pool and fsh to bridge
-	basePool, err := mv(r, "base", true)
+	basePool, err := common.Mv(r, "base", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid base pool")
+		common.SendErrorResponse(w, "Invalid base pool")
 		return
 	}
 
@@ -613,25 +614,25 @@ func HandleFSHBridging(w http.ResponseWriter, r *http.Request) {
 	basePoolObject, err := GetStoragePoolByOwner(basePool)
 	if err != nil {
 		log.Println("Bridge FSH failed: ", err.Error())
-		sendErrorResponse(w, "Storage pool not found")
+		common.SendErrorResponse(w, "Storage pool not found")
 		return
 	}
 
-	targetFSH, err := mv(r, "fsh", true)
+	targetFSH, err := common.Mv(r, "fsh", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid fsh given")
+		common.SendErrorResponse(w, "Invalid fsh given")
 		return
 	}
 
 	fsh, err := GetFsHandlerByUUID(targetFSH)
 	if err != nil {
-		sendErrorResponse(w, "Given FSH UUID does not exists")
+		common.SendErrorResponse(w, "Given FSH UUID does not exists")
 		return
 	}
 
 	err = BridgeFSHandlerToGroup(fsh, basePoolObject)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -643,31 +644,31 @@ func HandleFSHBridging(w http.ResponseWriter, r *http.Request) {
 	//Write changes to file
 	err = bridgeManager.AppendToConfig(&bridgeConfig)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func HandleFSHBridgeCheck(w http.ResponseWriter, r *http.Request) {
-	basePool, err := mv(r, "base", true)
+	basePool, err := common.Mv(r, "base", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid base pool")
+		common.SendErrorResponse(w, "Invalid base pool")
 		return
 	}
 
-	fsh, err := mv(r, "fsh", true)
+	fsh, err := common.Mv(r, "fsh", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid fsh UUID")
+		common.SendErrorResponse(w, "Invalid fsh UUID")
 		return
 	}
 
 	isBridged, err := bridgeManager.IsBridgedFSH(fsh, basePool)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	js, _ := json.Marshal(isBridged)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }

subservice.go

@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 
+	"imuslab.com/arozos/mod/common"
+	fs "imuslab.com/arozos/mod/filesystem"
 	prout "imuslab.com/arozos/mod/prouter"
 	subservice "imuslab.com/arozos/mod/subservice"
 )
@@ -50,7 +52,7 @@ func SubserviceInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -65,7 +67,7 @@ func SubserviceInit() {
 	//Scan and load all subservice modules
 	subservices, _ := filepath.Glob("./subservice/*")
 	for _, servicePath := range subservices {
-		if IsDir(servicePath) && !fileExists(servicePath+"/.disabled") {
+		if fs.IsDir(servicePath) && !fs.FileExists(servicePath+"/.disabled") {
 			//Only enable module with no suspended config file
 			ssRouter.Launch(servicePath, true)
 		}

system.go

@@ -9,6 +9,8 @@ import (
 	"strings"
 
 	uuid "github.com/satori/go.uuid"
+	"imuslab.com/arozos/mod/common"
+	fs "imuslab.com/arozos/mod/filesystem"
 )
 
 /*
@@ -61,7 +63,7 @@ func SystemIDInit() {
 	})
 
 	//Register vendor information
-	if fileExists("web/SystemAO/vendor/index.html") {
+	if fs.FileExists("web/SystemAO/vendor/index.html") {
 		registerSetting(settingModule{
 			Name:     "Vendor",
 			Desc:     "Vendor Notes",
@@ -90,11 +92,11 @@ func systemIdHandlePing(w http.ResponseWriter, r *http.Request) {
 	}{
 		"OK",
 	})
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 func systemIdGenerateSystemUUID() {
-	if !fileExists("./system/dev.uuid") {
+	if !fs.FileExists("./system/dev.uuid") {
 		//UUID not exist. Create one
 		thisuuid := uuid.NewV4().String()
 		if *system_uuid != "" {
@@ -136,13 +138,13 @@ func systemHandleListLicense(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(results)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 func systemIdHandleRequest(w http.ResponseWriter, r *http.Request) {
 	//Check if user has logged in
 	if authAgent.CheckAuth(r) == false {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
@@ -170,7 +172,7 @@ func systemIdHandleRequest(w http.ResponseWriter, r *http.Request) {
 		VendorIcon: iconVendor,
 	})
 
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func systemIdResponseBetaScan(w http.ResponseWriter, r *http.Request) {
@@ -207,5 +209,5 @@ func systemIdGetDriveStates(w http.ResponseWriter, r *http.Request) {
 		"-1B/-1B",
 	})
 	jsonString, _ := json.Marshal(results)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }

system.info.go

@@ -25,7 +25,7 @@ func SystemInfoInit() {
 		AdminOnly:   false,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -34,7 +34,7 @@ func SystemInfoInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -134,7 +134,7 @@ func SystemInfoInit() {
 			adminRouter.HandleFunc("/system/update/restart", func(w http.ResponseWriter, r *http.Request) {
 				launcherVersion, err := updates.GetLauncherVersion()
 				if err != nil {
-					sendErrorResponse(w, err.Error())
+					common.SendErrorResponse(w, err.Error())
 					return
 				}
 				execute, _ := common.Mv(r, "exec", true)
@@ -170,7 +170,7 @@ func InfoHandleGetRuntimeInfo(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(runtimeInfo)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }
 
 func InfoHandleTaskInfo(w http.ResponseWriter, r *http.Request) {
@@ -191,5 +191,5 @@ func InfoHandleTaskInfo(w http.ResponseWriter, r *http.Request) {
 	}
 
 	js, _ := json.Marshal(info)
-	sendJSONResponse(w, string(js))
+	common.SendJSONResponse(w, string(js))
 }

system.resetpw.go

@@ -22,52 +22,52 @@ func system_resetpw_init() {
 
 //Validate if the ysername and rkey is valid
 func system_resetpw_validateResetKeyHandler(w http.ResponseWriter, r *http.Request) {
-	username, err := mv(r, "username", true)
+	username, err := common.Mv(r, "username", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid username or key")
+		common.SendErrorResponse(w, "Invalid username or key")
 		return
 	}
-	rkey, err := mv(r, "rkey", true)
+	rkey, err := common.Mv(r, "rkey", true)
 	if err != nil {
-		sendErrorResponse(w, "Invalid username or key")
+		common.SendErrorResponse(w, "Invalid username or key")
 		return
 	}
 
 	if username == "" || rkey == "" {
-		sendErrorResponse(w, "Invalid username or rkey")
+		common.SendErrorResponse(w, "Invalid username or rkey")
 		return
 	}
 
 	//Check if the pair is valid
 	err = system_resetpw_validateResetKey(username, rkey)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 
 }
 
 func system_resetpw_confirmReset(w http.ResponseWriter, r *http.Request) {
-	username, _ := mv(r, "username", true)
-	rkey, _ := mv(r, "rkey", true)
-	newpw, _ := mv(r, "pw", true)
+	username, _ := common.Mv(r, "username", true)
+	rkey, _ := common.Mv(r, "rkey", true)
+	newpw, _ := common.Mv(r, "pw", true)
 	if username == "" || rkey == "" || newpw == "" {
-		sendErrorResponse(w, "Internal Server Error")
+		common.SendErrorResponse(w, "Internal Server Error")
 		return
 	}
 
 	//Check user exists
 	if !authAgent.UserExists(username) {
-		sendErrorResponse(w, "Username not exists")
+		common.SendErrorResponse(w, "Username not exists")
 		return
 	}
 
 	//Validate rkey
 	err := system_resetpw_validateResetKey(username, rkey)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
@@ -75,11 +75,11 @@ func system_resetpw_confirmReset(w http.ResponseWriter, r *http.Request) {
 	newHashedPassword := auth.Hash(newpw)
 	err = sysdb.Write("auth", "passhash/"+username, newHashedPassword)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	sendOK(w)
+	common.SendOK(w)
 
 }
 
@@ -102,13 +102,13 @@ func system_resetpw_validateResetKey(username string, key string) error {
 
 func system_resetpw_handlePasswordReset(w http.ResponseWriter, r *http.Request) {
 	//Check if the user click on this link with reset password key string. If not, ask the user to input one
-	acc, err := mv(r, "acc", false)
+	acc, err := common.Mv(r, "acc", false)
 	if err != nil || acc == "" {
 		system_resetpw_serveIdEnterInterface(w, r)
 		return
 	}
 
-	resetkey, err := mv(r, "rkey", false)
+	resetkey, err := common.Mv(r, "rkey", false)
 	if err != nil || resetkey == "" {
 		system_resetpw_serveIdEnterInterface(w, r)
 		return
@@ -117,12 +117,12 @@ func system_resetpw_handlePasswordReset(w http.ResponseWriter, r *http.Request)
 	//Check if the code is valid
 	err = system_resetpw_validateResetKey(acc, resetkey)
 	if err != nil {
-		sendErrorResponse(w, "Invalid username or resetKey")
+		common.SendErrorResponse(w, "Invalid username or resetKey")
 		return
 	}
 
 	//OK. Create the New Password Entering UI
-	imageBase64, _ := LoadImageAsBase64("./web/" + iconVendor)
+	imageBase64, _ := common.LoadImageAsBase64("./web/" + iconVendor)
 	template, err := common.Templateload("system/reset/resetPasswordTemplate.html", map[string]interface{}{
 		"vendor_logo": imageBase64,
 		"host_name":   *host_name,
@@ -138,7 +138,7 @@ func system_resetpw_handlePasswordReset(w http.ResponseWriter, r *http.Request)
 
 func system_resetpw_serveIdEnterInterface(w http.ResponseWriter, r *http.Request) {
 	//Reset Key or Username not found, Serve entering interface
-	imageBase64, _ := LoadImageAsBase64("./web/" + iconVendor)
+	imageBase64, _ := common.LoadImageAsBase64("./web/" + iconVendor)
 	template, err := common.Templateload("system/reset/resetCodeTemplate.html", map[string]interface{}{
 		"vendor_logo": imageBase64,
 		"host_name":   *host_name,

user.go

@@ -16,6 +16,7 @@ import (
 	uuid "github.com/satori/go.uuid"
 
 	auth "imuslab.com/arozos/mod/auth"
+	"imuslab.com/arozos/mod/common"
 	module "imuslab.com/arozos/mod/modules"
 	prout "imuslab.com/arozos/mod/prouter"
 	user "imuslab.com/arozos/mod/user"
@@ -35,7 +36,7 @@ func UserSystemInit() {
 			AdminOnly:   false,
 			UserHandler: userHandler,
 			DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-				sendErrorResponse(w, "Permission Denied")
+				common.SendErrorResponse(w, "Permission Denied")
 			},
 		})
 	*/
@@ -78,7 +79,7 @@ func UserSystemInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -90,33 +91,33 @@ func UserSystemInit() {
 
 //Remove a user from the system
 func user_handleUserRemove(w http.ResponseWriter, r *http.Request) {
-	username, err := mv(r, "username", true)
+	username, err := common.Mv(r, "username", true)
 	if err != nil {
-		sendErrorResponse(w, "Username not defined")
+		common.SendErrorResponse(w, "Username not defined")
 		return
 	}
 
 	if !authAgent.UserExists(username) {
-		sendErrorResponse(w, "User not exists")
+		common.SendErrorResponse(w, "User not exists")
 		return
 	}
 
 	userinfo, err := userHandler.GetUserInfoFromUsername(username)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	currentUserinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
 		//This user has not logged in
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	if currentUserinfo.Username == userinfo.Username {
 		//This user has not logged in
-		sendErrorResponse(w, "You can't remove yourself")
+		common.SendErrorResponse(w, "You can't remove yourself")
 		return
 	}
 
@@ -125,27 +126,27 @@ func user_handleUserRemove(w http.ResponseWriter, r *http.Request) {
 
 	//Clearn Up FileSystem preferences
 	system_fs_removeUserPreferences(username)
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
 		//This user has not logged in
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	if userinfo.IsAdmin() == false {
 		//Require admin access
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
-	opr, _ := mv(r, "opr", true)
-	username, _ := mv(r, "username", true)
+	opr, _ := common.Mv(r, "opr", true)
+	username, _ := common.Mv(r, "username", true)
 	if !authAgent.UserExists(username) {
-		sendErrorResponse(w, "User not exists")
+		common.SendErrorResponse(w, "User not exists")
 		return
 	}
 
@@ -160,7 +161,7 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		iconData := getUserIcon(username)
 		userGroup, err := permissionHandler.GetUsersPermissionGroup(username)
 		if err != nil {
-			sendErrorResponse(w, "Unable to get user group")
+			common.SendErrorResponse(w, "Unable to get user group")
 			return
 		}
 
@@ -180,27 +181,27 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 			Quota:     userinfo.StorageQuota.GetUserStorageQuota(),
 		})
 
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 	} else if opr == "updateUserGroup" {
 		//Update the target user's group
-		newgroup, err := mv(r, "newgroup", true)
+		newgroup, err := common.Mv(r, "newgroup", true)
 		if err != nil {
 			log.Println(err.Error())
-			sendErrorResponse(w, "New Group not defined")
+			common.SendErrorResponse(w, "New Group not defined")
 			return
 		}
 
-		newQuota, err := mv(r, "quota", true)
+		newQuota, err := common.Mv(r, "quota", true)
 		if err != nil {
 			log.Println(err.Error())
-			sendErrorResponse(w, "Quota not defined")
+			common.SendErrorResponse(w, "Quota not defined")
 			return
 		}
 
 		quotaInt, err := strconv.Atoi(newQuota)
 		if err != nil {
 			log.Println(err.Error())
-			sendErrorResponse(w, "Invalid Quota Value")
+			common.SendErrorResponse(w, "Invalid Quota Value")
 			return
 		}
 
@@ -208,19 +209,19 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		err = json.Unmarshal([]byte(newgroup), &newGroupKeys)
 		if err != nil {
 			log.Println(err.Error())
-			sendErrorResponse(w, "Unable to parse new groups")
+			common.SendErrorResponse(w, "Unable to parse new groups")
 			return
 		}
 
 		if len(newGroupKeys) == 0 {
-			sendErrorResponse(w, "User must be in at least one user permission group")
+			common.SendErrorResponse(w, "User must be in at least one user permission group")
 			return
 		}
 
 		//Check if each group exists
 		for _, thisgp := range newGroupKeys {
 			if !permissionHandler.GroupExists(thisgp) {
-				sendErrorResponse(w, "Group not exists, given: "+thisgp)
+				common.SendErrorResponse(w, "Group not exists, given: "+thisgp)
 				return
 			}
 		}
@@ -228,7 +229,7 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		//OK to proceed
 		userinfo, err := userHandler.GetUserInfoFromUsername(username)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
@@ -236,12 +237,12 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		allAdministratorGroupUsers, err := userHandler.GetUsersInPermissionGroup("administrator")
 		if err == nil {
 			//Skip checking if error
-			if len(allAdministratorGroupUsers) == 1 && userinfo.UserIsInOneOfTheGroupOf([]string{"administrator"}) && !stringInSlice("administrator", newGroupKeys) {
+			if len(allAdministratorGroupUsers) == 1 && userinfo.UserIsInOneOfTheGroupOf([]string{"administrator"}) && !common.StringInArray(newGroupKeys, "administrator") {
 				//Current administrator group only contain 1 user
 				//This user is in the administrator group
 				//The user want to unset himself from administrator group
 				//Reject the operation as this will cause system lockdown
-				sendErrorResponse(w, "You are the only administrator. You cannot remove yourself from the administrator group.")
+				common.SendErrorResponse(w, "You are the only administrator. You cannot remove yourself from the administrator group.")
 				return
 			}
 		}
@@ -252,14 +253,14 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		//Set the user's permission to these groups
 		userinfo.SetUserPermissionGroup(newPermissioGroups)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
 		//Write to quota handler
 		userinfo.StorageQuota.SetUserStorageQuota(int64(quotaInt))
 
-		sendOK(w)
+		common.SendOK(w)
 	} else if opr == "resetPassword" {
 		//Reset password for this user
 		//Generate a random password for this user
@@ -267,14 +268,14 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		hashedPassword := auth.Hash(tmppassword)
 		err := sysdb.Write("auth", "passhash/"+username, hashedPassword)
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 		//Finish. Send back the reseted password
-		sendJSONResponse(w, "\""+tmppassword+"\"")
+		common.SendJSONResponse(w, "\""+tmppassword+"\"")
 
 	} else {
-		sendErrorResponse(w, "Not supported opr")
+		common.SendErrorResponse(w, "Not supported opr")
 		return
 	}
 }
@@ -284,7 +285,7 @@ func user_getInterfaceInfo(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
 		//User not logged in
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
@@ -296,23 +297,23 @@ func user_getInterfaceInfo(w http.ResponseWriter, r *http.Request) {
 	}
 
 	jsonString, _ := json.Marshal(interfaceModuleInfos)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 	username, err := authAgent.GetUserName(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
-	opr, _ := mv(r, "opr", true)
+	opr, _ := common.Mv(r, "opr", true)
 
 	if opr == "" {
 		//Listing mode
 		iconData := getUserIcon(username)
 		userGroup, err := permissionHandler.GetUsersPermissionGroup(username)
 		if err != nil {
-			sendErrorResponse(w, "Unable to get user group")
+			common.SendErrorResponse(w, "Unable to get user group")
 			return
 		}
 
@@ -331,13 +332,13 @@ func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 			Usergroup: userGroupNames,
 		})
 
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 		return
 	} else if opr == "changepw" {
-		oldpw, _ := mv(r, "oldpw", true)
-		newpw, _ := mv(r, "newpw", true)
+		oldpw, _ := common.Mv(r, "oldpw", true)
+		newpw, _ := common.Mv(r, "newpw", true)
 		if oldpw == "" || newpw == "" {
-			sendErrorResponse(w, "Password cannot be empty")
+			common.SendErrorResponse(w, "Password cannot be empty")
 			return
 		}
 		//valid the old password
@@ -346,24 +347,24 @@ func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		err = sysdb.Read("auth", "passhash/"+username, &passwordInDB)
 		if hashedPassword != passwordInDB {
 			//Old password entry invalid.
-			sendErrorResponse(w, "Invalid old password.")
+			common.SendErrorResponse(w, "Invalid old password.")
 			return
 		}
 		//OK! Change user password
 		newHashedPassword := auth.Hash(newpw)
 		sysdb.Write("auth", "passhash/"+username, newHashedPassword)
-		sendOK(w)
+		common.SendOK(w)
 	} else if opr == "changeprofilepic" {
-		picdata, _ := mv(r, "picdata", true)
+		picdata, _ := common.Mv(r, "picdata", true)
 		if picdata != "" {
 			setUserIcon(username, picdata)
-			sendOK(w)
+			common.SendOK(w)
 		} else {
-			sendErrorResponse(w, "Empty image data received.")
+			common.SendErrorResponse(w, "Empty image data received.")
 			return
 		}
 	} else {
-		sendErrorResponse(w, "Not supported opr")
+		common.SendErrorResponse(w, "Not supported opr")
 		return
 	}
 }
@@ -372,7 +373,7 @@ func user_handleList(w http.ResponseWriter, r *http.Request) {
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
 		//This user has not logged in
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 	if authAgent.CheckAuth(r) {
@@ -396,9 +397,9 @@ func user_handleList(w http.ResponseWriter, r *http.Request) {
 		}
 
 		jsonString, _ := json.Marshal(results)
-		sendJSONResponse(w, string(jsonString))
+		common.SendJSONResponse(w, string(jsonString))
 	} else {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 	}
 }
 

web/SystemAO/security/connlog.html

@@ -124,6 +124,8 @@
                             $("#recordTables").parent().dropdown("set selected", getCurrentMonthTable());
                         }, 500);
                         loadRecordsByTableName(getCurrentMonthTable());
+                    }else{
+                        $("#normalStatus").text("No Record");
                     }
               
                     

wifi.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"strings"
 
+	"imuslab.com/arozos/mod/common"
 	wifi "imuslab.com/arozos/mod/network/wifi"
 	prout "imuslab.com/arozos/mod/prouter"
 )
@@ -31,7 +32,7 @@ func WiFiInit() {
 		AdminOnly:   true,
 		UserHandler: userHandler,
 		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
-			sendErrorResponse(w, "Permission Denied")
+			common.SendErrorResponse(w, "Permission Denied")
 		},
 	})
 
@@ -77,21 +78,21 @@ func network_wifi_handleWiFiPower(w http.ResponseWriter, r *http.Request) {
 	//Require admin permission to scan and connect wifi
 	user, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Internal Server Error")
+		common.SendErrorResponse(w, "Internal Server Error")
 		return
 	}
 
 	if !user.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
-	status, _ := mv(r, "status", true)
+	status, _ := common.Mv(r, "status", true)
 	if status == "" {
 		//Show current power status
 		infs, err := wifiManager.GetWirelessInterfaces()
 		if err != nil {
-			sendErrorResponse(w, err.Error())
+			common.SendErrorResponse(w, err.Error())
 			return
 		}
 
@@ -109,33 +110,33 @@ func network_wifi_handleWiFiPower(w http.ResponseWriter, r *http.Request) {
 			})
 		}
 
-		js, _ := json.Marshal(results);
-		sendJSONResponse(w, string(js))
+		js, _ := json.Marshal(results)
+		common.SendJSONResponse(w, string(js))
 
 	} else {
 		//Change current power status
-		wlaninterface, err := mv(r, "interface", true)
+		wlaninterface, err := common.Mv(r, "interface", true)
 		if err != nil {
-			sendErrorResponse(w, "Invalid interface")
+			common.SendErrorResponse(w, "Invalid interface")
 			return
 		}
 
 		if status == "on" {
 			err := wifiManager.SetInterfacePower(wlaninterface, true)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 			} else {
-				sendOK(w)
+				common.SendOK(w)
 			}
 		} else if status == "off" {
 			err := wifiManager.SetInterfacePower(wlaninterface, false)
 			if err != nil {
-				sendErrorResponse(w, err.Error())
+				common.SendErrorResponse(w, err.Error())
 			} else {
-				sendOK(w)
+				common.SendOK(w)
 			}
 		} else {
-			sendErrorResponse(w, "Invalid status")
+			common.SendErrorResponse(w, "Invalid status")
 		}
 	}
 
@@ -145,75 +146,75 @@ func network_wifi_handleScan(w http.ResponseWriter, r *http.Request) {
 	//Require admin permission to scan and connect wifi
 	user, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Internal Server Error")
+		common.SendErrorResponse(w, "Internal Server Error")
 		return
 	}
 
 	if !user.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
 	//Get a list of current on system wireless interface
 	wirelessInterfaces, err := wifiManager.GetWirelessInterfaces()
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 
 	if len(wirelessInterfaces) == 0 {
 		//No wireless interface
-		sendErrorResponse(w, "Wireless Interface Not Found")
+		common.SendErrorResponse(w, "Wireless Interface Not Found")
 		return
 	}
 
 	//Get the first ethernet interface and use it to scan nearby wifi
 	scannedWiFiInfo, err := wifiManager.ScanNearbyWiFi(wirelessInterfaces[0])
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 	jsonString, _ := json.Marshal(scannedWiFiInfo)
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }
 
 func network_wifi_handleConnect(w http.ResponseWriter, r *http.Request) {
 	user, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Internal Server Error")
+		common.SendErrorResponse(w, "Internal Server Error")
 		return
 	}
 	//Get information from client and create a new network config file
 	if !user.IsAdmin() {
-		sendErrorResponse(w, "Permission denied")
+		common.SendErrorResponse(w, "Permission denied")
 		return
 	}
 
-	ssid, err := mv(r, "ESSID", true)
+	ssid, err := common.Mv(r, "ESSID", true)
 	if err != nil {
-		sendErrorResponse(w, "ESSID not given")
+		common.SendErrorResponse(w, "ESSID not given")
 		return
 	}
-	connType, _ := mv(r, "ConnType", true)
-	password, _ := mv(r, "pwd", true)
+	connType, _ := common.Mv(r, "ConnType", true)
+	password, _ := common.Mv(r, "pwd", true)
 	log.Println("WiFi Switch Request Received. Genering Network Configuration...")
 
-	identity, err := mv(r, "identity", true)
+	identity, err := common.Mv(r, "identity", true)
 	if err != nil {
 		identity = ""
 	}
 
 	result, err := wifiManager.ConnectWiFi(ssid, password, connType, identity)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
 	jsonString, err := json.Marshal(result)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 		return
 	}
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 
 	log.Println("WiFi Connected")
 
@@ -223,40 +224,40 @@ func network_wifi_handleWiFiRemove(w http.ResponseWriter, r *http.Request) {
 	//Require admin permission to scan and connect wifi
 	user, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
-		sendErrorResponse(w, "Internal Server Error")
+		common.SendErrorResponse(w, "Internal Server Error")
 		return
 	}
 
 	if !user.IsAdmin() {
-		sendErrorResponse(w, "Permission Denied")
+		common.SendErrorResponse(w, "Permission Denied")
 		return
 	}
 
 	//Get ESSID from post request
-	ESSID, err := mv(r, "ESSID", true)
+	ESSID, err := common.Mv(r, "ESSID", true)
 	if err != nil {
-		sendErrorResponse(w, "ESSID not given")
+		common.SendErrorResponse(w, "ESSID not given")
 		return
 	}
 
 	err = wifiManager.RemoveWifi(ESSID)
 	if err != nil {
-		sendErrorResponse(w, err.Error())
+		common.SendErrorResponse(w, err.Error())
 	}
-	sendOK(w)
+	common.SendOK(w)
 }
 
 func network_wifi_handleWiFiInfo(w http.ResponseWriter, r *http.Request) {
 	//Get and return the current conencted WiFi Information
 	_, err := authAgent.GetUserName(w, r)
 	if err != nil {
-		sendErrorResponse(w, "User not logged in")
+		common.SendErrorResponse(w, "User not logged in")
 		return
 	}
 
 	ESSID, interfaceName, err := wifiManager.GetConnectedWiFi()
 	if err != nil {
-		sendErrorResponse(w, "Failed to retrieve WiFi Information")
+		common.SendErrorResponse(w, "Failed to retrieve WiFi Information")
 		return
 	}
 
@@ -264,5 +265,5 @@ func network_wifi_handleWiFiInfo(w http.ResponseWriter, r *http.Request) {
 		"ESSID":     ESSID,
 		"Interface": interfaceName,
 	})
-	sendJSONResponse(w, string(jsonString))
+	common.SendJSONResponse(w, string(jsonString))
 }