Replaced all Mv with GetPara or PostPara

agi.go

@@ -46,7 +46,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 := utils.Mv(r, "token", true)
+		token, err := utils.PostPara(r, "token")
 		if err != nil {
 			w.WriteHeader(http.StatusUnauthorized)
 			w.Write([]byte("401 - Unauthorized (token is empty)"))

desktop.go

@@ -129,14 +129,14 @@ func desktop_handleShortcutRename(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get the shortcut file that is renaming
-	target, err := utils.Mv(r, "src", false)
+	target, err := utils.GetPara(r, "src")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid shortcut file path given")
 		return
 	}
 
 	//Get the new name
-	new, err := utils.Mv(r, "new", false)
+	new, err := utils.GetPara(r, "new")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid new name given")
 		return
@@ -362,7 +362,7 @@ func desktop_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	nic, _ := utils.Mv(r, "noicon", true)
+	nic, _ := utils.PostPara(r, "noicon")
 	noicon := (nic == "true")
 
 	type returnStruct struct {
@@ -405,16 +405,16 @@ func desktop_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 
 // Icon handling function for web endpoint
 func desktop_fileLocation_handler(w http.ResponseWriter, r *http.Request) {
-	get, _ := utils.Mv(r, "get", true) //Check if there are get request for a given filepath
-	set, _ := utils.Mv(r, "set", true) //Check if there are any set request for a given filepath
-	del, _ := utils.Mv(r, "del", true) //Delete the given filename coordinate
+	get, _ := utils.PostPara(r, "get") //Check if there are get request for a given filepath
+	set, _ := utils.PostPara(r, "set") //Check if there are any set request for a given filepath
+	del, _ := utils.PostPara(r, "del") //Delete the given filename coordinate
 
 	if set != "" {
 		//Set location with given paramter
 		x := 0
 		y := 0
-		sx, _ := utils.Mv(r, "x", true)
-		sy, _ := utils.Mv(r, "y", true)
+		sx, _ := utils.PostPara(r, "x")
+		sy, _ := utils.PostPara(r, "y")
 		path := set
 
 		x, err := strconv.Atoi(sx)
@@ -461,9 +461,9 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 	username := userinfo.Username
 
 	//Check if the set GET paramter is set.
-	targetTheme, _ := utils.Mv(r, "set", false)
-	getUserTheme, _ := utils.Mv(r, "get", false)
-	loadUserTheme, _ := utils.Mv(r, "load", false)
+	targetTheme, _ := utils.GetPara(r, "set")
+	getUserTheme, _ := utils.GetPara(r, "get")
+	loadUserTheme, _ := utils.GetPara(r, "load")
 	if targetTheme == "" && getUserTheme == "" && loadUserTheme == "" {
 		//List all the currnet themes in the list
 		themes, err := filepath.Glob("web/img/desktop/bg/*")
@@ -588,9 +588,9 @@ func desktop_theme_handler(w http.ResponseWriter, r *http.Request) {
 }
 
 func desktop_preference_handler(w http.ResponseWriter, r *http.Request) {
-	preferenceType, _ := utils.Mv(r, "preference", true)
-	value, _ := utils.Mv(r, "value", true)
-	remove, _ := utils.Mv(r, "remove", true)
+	preferenceType, _ := utils.PostPara(r, "preference")
+	value, _ := utils.PostPara(r, "value")
+	remove, _ := utils.PostPara(r, "remove")
 	username, err := authAgent.GetUserName(w, r)
 	if err != nil {
 		//user not logged in. Redirect to login page.
@@ -633,31 +633,31 @@ func desktop_shortcutHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	shortcutType, err := utils.Mv(r, "stype", true)
+	shortcutType, err := utils.PostPara(r, "stype")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutText, err := utils.Mv(r, "stext", true)
+	shortcutText, err := utils.PostPara(r, "stext")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutPath, err := utils.Mv(r, "spath", true)
+	shortcutPath, err := utils.PostPara(r, "spath")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutIcon, err := utils.Mv(r, "sicon", true)
+	shortcutIcon, err := utils.PostPara(r, "sicon")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
 
-	shortcutCreationDest, err := utils.Mv(r, "sdest", true)
+	shortcutCreationDest, err := utils.PostPara(r, "sdest")
 	if err != nil {
 		//Default create on desktop
 		shortcutCreationDest = "user:/Desktop/"

file_system.go

@@ -237,20 +237,20 @@ func system_fs_handleFileSearch(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get the search target root path
-	vpath, err := utils.Mv(r, "path", true)
+	vpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid vpath given")
 		return
 	}
 
-	keyword, err := utils.Mv(r, "keyword", true)
+	keyword, err := utils.PostPara(r, "keyword")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid keyword given")
 		return
 	}
 
 	//Check if case sensitive is enabled
-	casesensitve, _ := utils.Mv(r, "casesensitive", true)
+	casesensitve, _ := utils.PostPara(r, "casesensitive")
 
 	vrootID, _, err := filesystem.GetIDFromVirtualPath(vpath)
 	var targetFSH *filesystem.FileSystemHandler = nil
@@ -369,7 +369,7 @@ func system_fs_handleLowMemoryUpload(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get filename and upload path
-	filename, err := utils.Mv(r, "filename", false)
+	filename, err := utils.GetPara(r, "filename")
 	if filename == "" || err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte("500 - Invalid filename given"))
@@ -377,7 +377,7 @@ func system_fs_handleLowMemoryUpload(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get upload target directory
-	uploadTarget, err := utils.Mv(r, "path", false)
+	uploadTarget, err := utils.GetPara(r, "path")
 	if uploadTarget == "" || err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte("500 - Invalid path given"))
@@ -416,7 +416,7 @@ func system_fs_handleLowMemoryUpload(w http.ResponseWriter, r *http.Request) {
 
 	//Check if it is huge file upload mode
 	isHugeFile := false
-	hugefile, _ := utils.Mv(r, "hugefile", false)
+	hugefile, _ := utils.GetPara(r, "hugefile")
 	if hugefile == "true" && !fsh.RequireBuffer {
 		//Huge file mode is only compatible with local file systems
 		//For remote file system, use buffer to tmp then upload method
@@ -754,7 +754,7 @@ func system_fs_handleUpload(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get upload target directory
-	uploadTarget, _ := utils.Mv(r, "path", true)
+	uploadTarget, _ := utils.PostPara(r, "path")
 	if uploadTarget == "" {
 		utils.SendErrorResponse(w, "Upload target cannot be empty.")
 		return
@@ -874,8 +874,8 @@ func system_fs_validateFileOpr(w http.ResponseWriter, r *http.Request) {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	vsrcFiles, _ := utils.Mv(r, "src", true)
-	vdestFile, _ := utils.Mv(r, "dest", true)
+	vsrcFiles, _ := utils.PostPara(r, "src")
+	vdestFile, _ := utils.PostPara(r, "dest")
 	var duplicateFiles []string = []string{}
 
 	//Loop through all files are see if there are duplication during copy and paste
@@ -1061,7 +1061,7 @@ func system_fs_restoreFile(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	targetTrashedFile, err := utils.Mv(r, "src", true)
+	targetTrashedFile, err := utils.PostPara(r, "src")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid src given")
 		return
@@ -1197,9 +1197,9 @@ func system_fs_handleNewObjects(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	fileType, _ := utils.Mv(r, "type", true)     //File creation type, {file, folder}
-	vsrc, _ := utils.Mv(r, "src", true)          //Virtual file source folder, do not include filename
-	filename, _ := utils.Mv(r, "filename", true) //Filename for the new file
+	fileType, _ := utils.PostPara(r, "type")     //File creation type, {file, folder}
+	vsrc, _ := utils.PostPara(r, "src")          //Virtual file source folder, do not include filename
+	filename, _ := utils.PostPara(r, "filename") //Filename for the new file
 
 	if fileType == "" && filename == "" {
 		//List all the supported new filetype
@@ -1321,10 +1321,10 @@ func system_fs_handleWebSocketOpr(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	operation, _ := utils.Mv(r, "opr", false) //Accept copy and move
-	vsrcFiles, _ := utils.Mv(r, "src", false)
-	vdestFile, _ := utils.Mv(r, "dest", false)
-	existsOpr, _ := utils.Mv(r, "existsresp", false)
+	operation, _ := utils.GetPara(r, "opr") //Accept copy and move
+	vsrcFiles, _ := utils.GetPara(r, "src")
+	vdestFile, _ := utils.GetPara(r, "dest")
+	existsOpr, _ := utils.GetPara(r, "existsresp")
 
 	if existsOpr == "" {
 		existsOpr = "keep"
@@ -1697,10 +1697,10 @@ func system_fs_handleOpr(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	operation, _ := utils.Mv(r, "opr", true)
-	vsrcFiles, _ := utils.Mv(r, "src", true)
-	vdestFile, _ := utils.Mv(r, "dest", true)
-	vnfilenames, _ := utils.Mv(r, "new", true) //Only use when rename or create new file / folder
+	operation, _ := utils.PostPara(r, "opr")
+	vsrcFiles, _ := utils.PostPara(r, "src")
+	vdestFile, _ := utils.PostPara(r, "dest")
+	vnfilenames, _ := utils.PostPara(r, "new") //Only use when rename or create new file / folder
 
 	//Check if operation valid.
 	if operation == "" {
@@ -1897,7 +1897,7 @@ func system_fs_handleOpr(w http.ResponseWriter, r *http.Request) {
 				}
 
 				//Get exists overwrite mode
-				existsOpr, _ := utils.Mv(r, "existsresp", true)
+				existsOpr, _ := utils.PostPara(r, "existsresp")
 
 				//Check if use fast move instead
 				//Check if the source and destination folder are under the same root. If yes, use os.Rename for faster move operations
@@ -1949,7 +1949,7 @@ func system_fs_handleOpr(w http.ResponseWriter, r *http.Request) {
 					return
 				}
 
-				existsOpr, _ := utils.Mv(r, "existsresp", true)
+				existsOpr, _ := utils.PostPara(r, "existsresp")
 
 				//Check if the user have space for the extra file
 				if !userinfo.StorageQuota.HaveSpace(filesystem.GetFileSize(rdestFile)) {
@@ -2122,9 +2122,9 @@ func system_fs_handleUserPreference(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	key, _ := utils.Mv(r, "key", false)
-	value, _ := utils.Mv(r, "value", false)
-	remove, _ := utils.Mv(r, "remove", false)
+	key, _ := utils.GetPara(r, "key")
+	value, _ := utils.GetPara(r, "value")
+	remove, _ := utils.GetPara(r, "remove")
 
 	if key != "" && value == "" && remove == "" {
 		//Get mode. Read the prefernece with given key
@@ -2229,7 +2229,7 @@ func system_fs_listRoot(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	username := userinfo.Username
-	userRoot, _ := utils.Mv(r, "user", false)
+	userRoot, _ := utils.GetPara(r, "user")
 	if userRoot == "true" {
 		type fileObject struct {
 			Filename string
@@ -2353,7 +2353,7 @@ func system_fs_getFileProperties(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	vpath, err := utils.Mv(r, "path", true)
+	vpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "path not defined")
 		return
@@ -2446,11 +2446,21 @@ func system_fs_getFileProperties(w http.ResponseWriter, r *http.Request) {
 */
 
 func system_fs_handleList(w http.ResponseWriter, r *http.Request) {
-	currentDir, _ := utils.Mv(r, "dir", true)
+	currentDir, err := utils.PostPara(r, "dir")
+	if err != nil {
+		utils.SendErrorResponse(w, err.Error())
+		return
+	}
 	//Commented this line to handle dirname that contains "+" sign
 	//currentDir, _ = url.QueryUnescape(currentDir)
-	sortMode, _ := utils.Mv(r, "sort", true)
-	showHidden, _ := utils.Mv(r, "showHidden", true)
+	sortMode, err := utils.PostPara(r, "sort")
+	if err != nil {
+		utils.SendErrorResponse(w, err.Error())
+		return
+	}
+
+	showHidden, _ := utils.PostPara(r, "showHidden")
+
 	userinfo, err := userHandler.GetUserInfoFromRequest(w, r)
 	if err != nil {
 		//user not logged in. Redirect to login page.
@@ -2588,7 +2598,7 @@ func system_fs_handleList(w http.ResponseWriter, r *http.Request) {
 
 //Handle getting a hash from a given contents in the given path
 func system_fs_handleDirHash(w http.ResponseWriter, r *http.Request) {
-	currentDir, err := utils.Mv(r, "dir", true)
+	currentDir, err := utils.GetPara(r, "dir")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid dir given")
 		return
@@ -2666,19 +2676,19 @@ func system_fs_zipHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	opr, err := utils.Mv(r, "opr", true)
+	opr, err := utils.PostPara(r, "opr")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid opr or opr not defined")
 		return
 	}
 
-	vsrc, _ := utils.Mv(r, "src", true)
+	vsrc, _ := utils.PostPara(r, "src")
 	if vsrc == "" {
 		utils.SendErrorResponse(w, "Invalid src paramter")
 		return
 	}
 
-	vdest, _ := utils.Mv(r, "dest", true)
+	vdest, _ := utils.PostPara(r, "dest")
 	rdest := ""
 
 	//Convert source path from JSON string to object
@@ -2783,7 +2793,7 @@ func system_fs_FileVersionHistory(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	path, err := utils.Mv(r, "path", true)
+	path, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid path given")
 		return
@@ -2798,7 +2808,7 @@ func system_fs_FileVersionHistory(w http.ResponseWriter, r *http.Request) {
 	}
 	fshAbs := fsh.FileSystemAbstraction
 
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 
 	rpath, err := fshAbs.VirtualPathToRealPath(subpath, userinfo.Username)
 	if err != nil {
@@ -2820,7 +2830,7 @@ func system_fs_FileVersionHistory(w http.ResponseWriter, r *http.Request) {
 
 	} else if opr == "delete" {
 		//Delete file history of given history ID
-		historyID, err := utils.Mv(r, "histid", true)
+		historyID, err := utils.PostPara(r, "histid")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid history id given")
 			return
@@ -2845,7 +2855,7 @@ func system_fs_FileVersionHistory(w http.ResponseWriter, r *http.Request) {
 
 	} else if opr == "restore" {
 		//Restore file history of given history ID
-		historyID, err := utils.Mv(r, "histid", true)
+		historyID, err := utils.PostPara(r, "histid")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid history id given")
 			return
@@ -2885,7 +2895,7 @@ func system_fs_clearVersionHistories() {
 //Handle cache rendering with websocket pipeline
 func system_fs_handleCacheRender(w http.ResponseWriter, r *http.Request) {
 	userinfo, _ := userHandler.GetUserInfoFromRequest(w, r)
-	vpath, err := utils.Mv(r, "folder", false)
+	vpath, err := utils.GetPara(r, "folder")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid folder paramter")
 		return
@@ -2912,13 +2922,13 @@ func system_fs_handleCacheRender(w http.ResponseWriter, r *http.Request) {
 //Handle loading of one thumbnail
 func system_fs_handleThumbnailLoad(w http.ResponseWriter, r *http.Request) {
 	userinfo, _ := userHandler.GetUserInfoFromRequest(w, r)
-	vpath, err := utils.Mv(r, "vpath", false)
+	vpath, err := utils.GetPara(r, "vpath")
 	if err != nil {
 		utils.SendErrorResponse(w, "vpath not defined")
 		return
 	}
 
-	byteMode, _ := utils.Mv(r, "bytes", false)
+	byteMode, _ := utils.GetPara(r, "bytes")
 	isByteMode := byteMode == "true"
 	fsh, subpath, err := GetFSHandlerSubpathFromVpath(vpath)
 	if err != nil {
@@ -2963,7 +2973,7 @@ func system_fs_handleThumbnailLoad(w http.ResponseWriter, r *http.Request) {
 //Handle file thumbnail caching
 func system_fs_handleFolderCache(w http.ResponseWriter, r *http.Request) {
 	userinfo, _ := userHandler.GetUserInfoFromRequest(w, r)
-	vfolderpath, err := utils.Mv(r, "folder", false)
+	vfolderpath, err := utils.GetPara(r, "folder")
 	if err != nil {
 		utils.SendErrorResponse(w, "folder not defined")
 		return
@@ -2986,13 +2996,13 @@ func system_fs_handleFolderSortModePreference(w http.ResponseWriter, r *http.Req
 		utils.SendErrorResponse(w, "User not logged in")
 		return
 	}
-	folder, err := utils.Mv(r, "folder", true)
+	folder, err := utils.PostPara(r, "folder")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid folder given")
 		return
 	}
 
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 
 	folder = filepath.ToSlash(filepath.Clean(folder))
 
@@ -3009,7 +3019,7 @@ func system_fs_handleFolderSortModePreference(w http.ResponseWriter, r *http.Req
 		}
 		utils.SendJSONResponse(w, string(js))
 	} else if opr == "set" {
-		sortMode, err := utils.Mv(r, "mode", true)
+		sortMode, err := utils.PostPara(r, "mode")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid sort mode given")
 			return
@@ -3030,7 +3040,7 @@ func system_fs_handleFolderSortModePreference(w http.ResponseWriter, r *http.Req
 
 //Handle setting and loading of file permission on Linux
 func system_fs_handleFilePermission(w http.ResponseWriter, r *http.Request) {
-	file, err := utils.Mv(r, "file", true)
+	file, err := utils.PostPara(r, "file")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid file")
 		return
@@ -3050,7 +3060,7 @@ func system_fs_handleFilePermission(w http.ResponseWriter, r *http.Request) {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	newMode, _ := utils.Mv(r, "mode", true)
+	newMode, _ := utils.PostPara(r, "mode")
 	if newMode == "" {
 		//Read the file mode
 

hardware.power.go

@@ -56,7 +56,7 @@ func hardware_power_poweroff(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Double check password for this user
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		utils.SendErrorResponse(w, "Password Incorrect")
 		return
@@ -123,7 +123,7 @@ func hardware_power_restart(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Double check password for this user
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		utils.SendErrorResponse(w, "Password Incorrect")
 		return

legacy/backup.go.disabled

@@ -122,14 +122,14 @@ func backup_renderSnapshotSummary(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get Backup disk ID from request
-	bdid, err := utils.Mv(r, "bdid", true)
+	bdid, err := utils.PostPara(r,"bdid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid backup disk ID given")
 		return
 	}
 
 	//Get target snapshot name from request
-	snapshot, err := utils.Mv(r, "snapshot", true)
+	snapshot, err := utils.PostPara(r,"snapshot")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid snapshot name given")
 		return
@@ -199,7 +199,7 @@ func backup_restoreSelected(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get Backup disk ID from request
-	bdid, err := utils.Mv(r, "bdid", true)
+	bdid, err := utils.PostPara(r,"bdid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid backup disk ID given")
 		return
@@ -213,7 +213,7 @@ func backup_restoreSelected(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get the relative path for the restorable file
-	relpath, err := utils.Mv(r, "relpath", true)
+	relpath, err := utils.PostPara(r,"relpath")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid relative path given")
 		return
@@ -302,7 +302,7 @@ func backup_listRestorable(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get Vroot ID from request
-	vroot, err := utils.Mv(r, "vroot", true)
+	vroot, err := utils.PostPara(r,"vroot")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid vroot given")
 		return

main.flags.go

@@ -29,7 +29,7 @@ var subserviceBasePort = 12810            //Next subservice port
 
 // =========== SYSTEM BUILD INFORMATION ==============
 var build_version = "development"                      //System build flag, this can be either {development / production / stable}
-var internal_version = "0.2.007"                       //Internal build version, [fork_id].[major_release_no].[minor_release_no]
+var internal_version = "0.2.008"                       //Internal build version, [fork_id].[major_release_no].[minor_release_no]
 var deviceUUID string                                  //The device uuid of this host
 var deviceVendor = "IMUSLAB.INC"                       //Vendor of the system
 var deviceVendorURL = "http://imuslab.com"             //Vendor contact information

main.router.go

@@ -30,7 +30,7 @@ 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, _ := utils.Mv(r, "redirect", false)
+			red, _ := utils.GetPara(r, "redirect")
 
 			//Append the redirection addr into the template
 			imgsrc := "./web/" + iconSystem

mediaServer.go

@@ -60,7 +60,7 @@ func media_server_validateSourceFile(w http.ResponseWriter, r *http.Request) (*f
 		return nil, "", "", errors.New("Invalid paramters. Multiple ? found")
 	}
 
-	targetfile, _ := utils.Mv(r, "file", false)
+	targetfile, _ := utils.GetPara(r, "file")
 	targetfile, err = url.QueryUnescape(targetfile)
 	if err != nil {
 		return nil, "", "", err
@@ -156,7 +156,7 @@ func serverMedia(w http.ResponseWriter, r *http.Request) {
 
 	//Check if downloadMode
 	downloadMode := false
-	dw, _ := utils.Mv(r, "download", false)
+	dw, _ := utils.GetPara(r, "download")
 	if dw == "true" {
 		downloadMode = true
 	}

mod/agi/agi.go

@@ -201,7 +201,7 @@ func (g *Gateway) filterDBTable(tablename string, existsCheck bool) bool {
 
 //Handle request from RESTFUL API
 func (g *Gateway) APIHandler(w http.ResponseWriter, r *http.Request, thisuser *user.User) {
-	scriptContent, err := utils.Mv(r, "script", true)
+	scriptContent, err := utils.PostPara(r, "script")
 	if err != nil {
 		w.WriteHeader(http.StatusBadRequest)
 		w.Write([]byte("400 - Bad Request (Missing script content)"))
@@ -217,7 +217,7 @@ func (g *Gateway) InterfaceHandler(w http.ResponseWriter, r *http.Request, thisu
 	startupRoot = filepath.ToSlash(filepath.Clean(startupRoot))
 
 	//Get the script files for the plugin
-	scriptFile, err := utils.Mv(r, "script", false)
+	scriptFile, err := utils.GetPara(r, "script")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid script path")
 		return

mod/agi/agi.serverless.go

@@ -23,7 +23,7 @@ func (g *Gateway) injectServerlessFunctions(vm *otto.Otto, scriptFile string, sc
 		if key == "" {
 			return otto.NullValue()
 		}
-		value, err := utils.Mv(r, key, false)
+		value, err := utils.GetPara(r, key)
 		if err != nil {
 			return otto.NullValue()
 		}
@@ -40,7 +40,7 @@ func (g *Gateway) injectServerlessFunctions(vm *otto.Otto, scriptFile string, sc
 		if key == "" {
 			return otto.NullValue()
 		}
-		value, err := utils.Mv(r, key, true)
+		value, err := utils.PostPara(r, key)
 		if err != nil {
 			return otto.NullValue()
 		}

mod/agi/external.agi.go

@@ -90,7 +90,7 @@ func (g *Gateway) AddExternalEndPoint(w http.ResponseWriter, r *http.Request) {
 	var dat endpointFormat
 
 	// uuid: [path, id]
-	path, err := utils.Mv(r, "path", false)
+	path, err := utils.GetPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid path given")
 		return
@@ -126,7 +126,7 @@ func (g *Gateway) RemoveExternalEndPoint(w http.ResponseWriter, r *http.Request)
 		sysdb.NewTable("external_agi")
 	}
 	// get path
-	uuid, err := utils.Mv(r, "uuid", false)
+	uuid, err := utils.GetPara(r, "uuid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid uuid given")
 		return

mod/agi/handler.go

@@ -10,14 +10,14 @@ import (
 
 //Handle AGI Exectuion Request with token, design for letting other web scripting language like php to interface with AGI
 func (g *Gateway) HandleAgiExecutionRequestWithToken(w http.ResponseWriter, r *http.Request) {
-	token, err := utils.Mv(r, "token", false)
+	token, err := utils.GetPara(r, "token")
 	if err != nil {
 		//Username not defined
 		utils.SendErrorResponse(w, "Token not defined or empty.")
 		return
 	}
 
-	script, err := utils.Mv(r, "script", false)
+	script, err := utils.GetPara(r, "script")
 	if err != nil {
 		//Username not defined
 		utils.SendErrorResponse(w, "Script path not defined or empty.")

mod/auth/accesscontrol/blacklist/handler.go

@@ -15,7 +15,7 @@ import (
 */
 
 func (bl *BlackList) HandleAddBannedIP(w http.ResponseWriter, r *http.Request) {
-	ipRange, err := utils.Mv(r, "iprange", true)
+	ipRange, err := utils.PostPara(r, "iprange")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid ip range given")
 		return
@@ -31,7 +31,7 @@ func (bl *BlackList) HandleAddBannedIP(w http.ResponseWriter, r *http.Request) {
 }
 
 func (bl *BlackList) HandleRemoveBannedIP(w http.ResponseWriter, r *http.Request) {
-	ipRange, err := utils.Mv(r, "iprange", true)
+	ipRange, err := utils.PostPara(r, "iprange")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid ip range given")
 		return
@@ -47,7 +47,7 @@ func (bl *BlackList) HandleRemoveBannedIP(w http.ResponseWriter, r *http.Request
 }
 
 func (bl *BlackList) HandleSetBlacklistEnable(w http.ResponseWriter, r *http.Request) {
-	enableMode, _ := utils.Mv(r, "enable", true)
+	enableMode, _ := utils.PostPara(r, "enable")
 	if enableMode == "" {
 		//Get the current blacklist status
 		js, _ := json.Marshal(bl.Enabled)

mod/auth/accesscontrol/whitelist/handler.go

@@ -10,7 +10,7 @@ import (
 )
 
 func (wl *WhiteList) HandleAddWhitelistedIP(w http.ResponseWriter, r *http.Request) {
-	ipRange, err := utils.Mv(r, "iprange", true)
+	ipRange, err := utils.PostPara(r, "iprange")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid ip range given")
 		return
@@ -26,7 +26,7 @@ func (wl *WhiteList) HandleAddWhitelistedIP(w http.ResponseWriter, r *http.Reque
 }
 
 func (wl *WhiteList) HandleRemoveWhitelistedIP(w http.ResponseWriter, r *http.Request) {
-	ipRange, err := utils.Mv(r, "iprange", true)
+	ipRange, err := utils.PostPara(r, "iprange")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid ip range given")
 		return
@@ -42,7 +42,7 @@ func (wl *WhiteList) HandleRemoveWhitelistedIP(w http.ResponseWriter, r *http.Re
 }
 
 func (wl *WhiteList) HandleSetWhitelistEnable(w http.ResponseWriter, r *http.Request) {
-	enableMode, _ := utils.Mv(r, "enable", true)
+	enableMode, _ := utils.PostPara(r, "enable")
 	if enableMode == "" {
 		//Get the current whitelist status
 		js, _ := json.Marshal(wl.Enabled)

mod/auth/auth.go

@@ -168,7 +168,7 @@ func (a *AuthAgent) HandleCheckAuth(w http.ResponseWriter, r *http.Request, hand
 func (a *AuthAgent) HandleLogin(w http.ResponseWriter, r *http.Request) {
 
 	//Get username from request using POST mode
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		//Username not defined
 		log.Println("[System Auth] Someone trying to login with username: " + username)
@@ -179,7 +179,7 @@ func (a *AuthAgent) HandleLogin(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get password from request using POST mode
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		//Password not defined
 		a.Logger.LogAuth(r, false)
@@ -189,7 +189,7 @@ func (a *AuthAgent) HandleLogin(w http.ResponseWriter, r *http.Request) {
 
 	//Get rememberme settings
 	rememberme := false
-	rmbme, _ := utils.Mv(r, "rmbme", true)
+	rmbme, _ := utils.PostPara(r, "rmbme")
 	if rmbme == "true" {
 		rememberme = true
 	}
@@ -363,21 +363,21 @@ func (a *AuthAgent) HandleRegister(w http.ResponseWriter, r *http.Request) {
 	userCount := a.GetUserCounts()
 
 	//Get username from request
-	newusername, err := utils.Mv(r, "username", true)
+	newusername, err := utils.PostPara(r, "username")
 	if err != nil {
 		sendTextResponse(w, "Error. Missing 'username' paramter")
 		return
 	}
 
 	//Get password from request
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		sendTextResponse(w, "Error. Missing 'password' paramter")
 		return
 	}
 
 	//Set permission group to default
-	group, err := utils.Mv(r, "group", true)
+	group, err := utils.PostPara(r, "group")
 	if err != nil {
 		sendTextResponse(w, "Error. Missing 'group' paramter")
 		return
@@ -436,7 +436,7 @@ func (a *AuthAgent) HandleUnregister(w http.ResponseWriter, r *http.Request) {
 	*/
 
 	//Get username from request
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		sendErrorResponse(w, "Missing 'username' paramter")
 		return

mod/auth/authlogger/authlogger.go

@@ -50,7 +50,7 @@ func NewLogger() (*Logger, error) {
 
 //Log the current authentication to record, Require the request object and login status
 func (l *Logger) LogAuth(r *http.Request, loginStatus bool) error {
-	username, _ := utils.Mv(r, "username", true)
+	username, _ := utils.PostPara(r, "username")
 	timestamp := time.Now().Unix()
 	//handling the reverse proxy remote IP issue
 	remoteIP := r.Header.Get("X-FORWARDED-FOR")

mod/auth/authlogger/handlers.go

@@ -48,7 +48,7 @@ func (l *Logger) HandleIndexListing(w http.ResponseWriter, r *http.Request) {
 //Handle of the listing of a given index (month)
 func (l *Logger) HandleTableListing(w http.ResponseWriter, r *http.Request) {
 	//Get the record name request for listing
-	month, err := utils.Mv(r, "record", true)
+	month, err := utils.PostPara(r, "record")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return

mod/auth/autologin.go

@@ -113,7 +113,7 @@ func (a *AuthAgent) HandleAutologinTokenLogin(w http.ResponseWriter, r *http.Req
 	}
 
 	session, _ := a.SessionStore.Get(r, a.SessionName)
-	token, err := utils.Mv(r, "token", false)
+	token, err := utils.GetPara(r, "token")
 	if err != nil {
 		//Username not defined
 		sendErrorResponse(w, "Token not defined or empty.")
@@ -164,7 +164,7 @@ func (a *AuthAgent) HandleAutologinTokenLogin(w http.ResponseWriter, r *http.Req
 
 	session.Save(r, w)
 
-	redirectTarget, _ := utils.Mv(r, "redirect", false)
+	redirectTarget, _ := utils.GetPara(r, "redirect")
 	if redirectTarget != "" {
 		//Redirect to target website
 		http.Redirect(w, r, redirectTarget, http.StatusTemporaryRedirect)

mod/auth/autologin/autologin.go

@@ -20,7 +20,7 @@ func NewAutoLoginHandler(uh *user.UserHandler) *AutoLoginHandler {
 
 //List the token given the username
 func (a *AutoLoginHandler) HandleUserTokensListing(w http.ResponseWriter, r *http.Request) {
-	username, err := utils.Mv(r, "username", false)
+	username, err := utils.GetPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid username")
 		return
@@ -42,7 +42,7 @@ func (a *AutoLoginHandler) HandleUserTokensListing(w http.ResponseWriter, r *htt
 
 //Handle User Token Creation, require username. Please use adminrouter to handle this function
 func (a *AutoLoginHandler) HandleUserTokenCreation(w http.ResponseWriter, r *http.Request) {
-	username, err := utils.Mv(r, "username", false)
+	username, err := utils.GetPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid username")
 		return
@@ -63,7 +63,7 @@ func (a *AutoLoginHandler) HandleUserTokenCreation(w http.ResponseWriter, r *htt
 
 //Remove the user token given the token
 func (a *AutoLoginHandler) HandleUserTokenRemoval(w http.ResponseWriter, r *http.Request) {
-	token, err := utils.Mv(r, "token", false)
+	token, err := utils.GetPara(r, "token")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid username")
 		return

mod/auth/batch.go

@@ -26,7 +26,7 @@ import (
 	Each user occupied one new line
 */
 func (a *AuthAgent) HandleCreateUserAccountsFromCSV(w http.ResponseWriter, r *http.Request) {
-	csvContent, err := utils.Mv(r, "csv", true)
+	csvContent, err := utils.PostPara(r, "csv")
 	if err != nil {
 		sendErrorResponse(w, "Invalid csv")
 		return
@@ -70,13 +70,13 @@ func (a *AuthAgent) HandleCreateUserAccountsFromCSV(w http.ResponseWriter, r *ht
 	Require paramter: group, exact
 */
 func (a *AuthAgent) HandleUserDeleteByGroup(w http.ResponseWriter, r *http.Request) {
-	group, err := utils.Mv(r, "group", true)
+	group, err := utils.PostPara(r, "group")
 	if err != nil {
 		sendErrorResponse(w, "Invalid group")
 	}
 
 	requireExact := true //Default true
-	exact, _ := utils.Mv(r, "exact", true)
+	exact, _ := utils.PostPara(r, "exact")
 	if exact == "false" {
 		requireExact = false
 	}

mod/auth/ldap/web_admin.go

@@ -45,7 +45,7 @@ func (ldap *ldapHandler) ReadConfig(w http.ResponseWriter, r *http.Request) {
 
 func (ldap *ldapHandler) WriteConfig(w http.ResponseWriter, r *http.Request) {
 	//receive the parameter
-	enabled, err := utils.Mv(r, "enabled", true)
+	enabled, err := utils.PostPara(r, "enabled")
 	if err != nil {
 		utils.SendErrorResponse(w, "enabled field can't be empty")
 		return
@@ -58,28 +58,28 @@ func (ldap *ldapHandler) WriteConfig(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//four fields to store the LDAP authentication information
-	BindUsername, err := utils.Mv(r, "bind_username", true)
+	BindUsername, err := utils.PostPara(r, "bind_username")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "bind_username field can't be empty")
 			return
 		}
 	}
-	BindPassword, err := utils.Mv(r, "bind_password", true)
+	BindPassword, err := utils.PostPara(r, "bind_password")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "bind_password field can't be empty")
 			return
 		}
 	}
-	FQDN, err := utils.Mv(r, "fqdn", true)
+	FQDN, err := utils.PostPara(r, "fqdn")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "fqdn field can't be empty")
 			return
 		}
 	}
-	BaseDN, err := utils.Mv(r, "base_dn", true)
+	BaseDN, err := utils.PostPara(r, "base_dn")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "base_dn field can't be empty")

mod/auth/ldap/web_login.go

@@ -18,7 +18,7 @@ func (ldap *ldapHandler) HandleLoginPage(w http.ResponseWriter, r *http.Request)
 		return
 	}
 	//load the template from file and inject necessary variables
-	red, _ := utils.Mv(r, "redirect", false)
+	red, _ := utils.GetPara(r, "redirect")
 
 	//Append the redirection addr into the template
 	imgsrc := "./web/" + ldap.iconSystem
@@ -46,17 +46,17 @@ func (ldap *ldapHandler) HandleNewPasswordPage(w http.ResponseWriter, r *http.Re
 		return
 	}
 	//get the parameter from the request
-	acc, err := utils.Mv(r, "username", false)
+	acc, err := utils.GetPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	displayname, err := utils.Mv(r, "displayname", false)
+	displayname, err := utils.GetPara(r, "displayname")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	key, err := utils.Mv(r, "authkey", false)
+	key, err := utils.GetPara(r, "authkey")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
@@ -87,7 +87,7 @@ func (ldap *ldapHandler) HandleLogin(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	//Get username from request using POST mode
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		//Username not defined
 		log.Println("[System Auth] Someone trying to login with username: " + username)
@@ -98,7 +98,7 @@ func (ldap *ldapHandler) HandleLogin(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get password from request using POST mode
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		//Password not defined
 		ldap.ag.Logger.LogAuth(r, false)
@@ -108,7 +108,7 @@ func (ldap *ldapHandler) HandleLogin(w http.ResponseWriter, r *http.Request) {
 
 	//Get rememberme settings
 	rememberme := false
-	rmbme, _ := utils.Mv(r, "rmbme", true)
+	rmbme, _ := utils.PostPara(r, "rmbme")
 	if rmbme == "true" {
 		rememberme = true
 	}
@@ -152,17 +152,17 @@ func (ldap *ldapHandler) HandleSetPassword(w http.ResponseWriter, r *http.Reques
 		return
 	}
 	//get paramters from request
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return
 	}
-	authkey, err := utils.Mv(r, "authkey", true)
+	authkey, err := utils.PostPara(r, "authkey")
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
 		return

mod/auth/oauth2/oauth2.go

@@ -68,7 +68,7 @@ func (oh *OauthHandler) HandleLogin(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	//add cookies
-	redirect, err := utils.Mv(r, "redirect", false)
+	redirect, err := utils.GetPara(r, "redirect")
 	//store the redirect url to the sync map
 	uuid := ""
 	if err != nil {
@@ -97,7 +97,7 @@ func (oh *OauthHandler) HandleAuthorize(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	state, err := utils.Mv(r, "state", true)
+	state, err := utils.PostPara(r, "state")
 	if state != uuid.Value {
 		utils.SendTextResponse(w, "Invalid oauth state.")
 		return
@@ -107,7 +107,7 @@ func (oh *OauthHandler) HandleAuthorize(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	code, err := utils.Mv(r, "code", true)
+	code, err := utils.PostPara(r, "code")
 	if err != nil {
 		utils.SendTextResponse(w, "Invalid state parameter.")
 		return
@@ -238,12 +238,12 @@ func (oh *OauthHandler) ReadConfig(w http.ResponseWriter, r *http.Request) {
 }
 
 func (oh *OauthHandler) WriteConfig(w http.ResponseWriter, r *http.Request) {
-	enabled, err := utils.Mv(r, "enabled", true)
+	enabled, err := utils.PostPara(r, "enabled")
 	if err != nil {
 		utils.SendErrorResponse(w, "enabled field can't be empty")
 		return
 	}
-	autoredirect, err := utils.Mv(r, "autoredirect", true)
+	autoredirect, err := utils.PostPara(r, "autoredirect")
 	if err != nil {
 		utils.SendErrorResponse(w, "enabled field can't be empty")
 		return
@@ -254,21 +254,21 @@ func (oh *OauthHandler) WriteConfig(w http.ResponseWriter, r *http.Request) {
 		showError = false
 	}
 
-	idp, err := utils.Mv(r, "idp", true)
+	idp, err := utils.PostPara(r, "idp")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "idp field can't be empty")
 			return
 		}
 	}
-	redirecturl, err := utils.Mv(r, "redirecturl", true)
+	redirecturl, err := utils.PostPara(r, "redirecturl")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "redirecturl field can't be empty")
 			return
 		}
 	}
-	serverurl, err := utils.Mv(r, "serverurl", true)
+	serverurl, err := utils.PostPara(r, "serverurl")
 	if err != nil {
 		if showError {
 			if idp != "Gitlab" {
@@ -283,14 +283,14 @@ func (oh *OauthHandler) WriteConfig(w http.ResponseWriter, r *http.Request) {
 		serverurl = ""
 	}
 
-	clientid, err := utils.Mv(r, "clientid", true)
+	clientid, err := utils.PostPara(r, "clientid")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "clientid field can't be empty")
 			return
 		}
 	}
-	clientsecret, err := utils.Mv(r, "clientsecret", true)
+	clientsecret, err := utils.PostPara(r, "clientsecret")
 	if err != nil {
 		if showError {
 			utils.SendErrorResponse(w, "clientsecret field can't be empty")

mod/auth/register/register.go

@@ -205,7 +205,7 @@ func (h *RegisterHandler) HandleRegisterRequest(w http.ResponseWriter, r *http.R
 		return
 	}
 	//Get input paramter
-	email, err := utils.Mv(r, "email", true)
+	email, err := utils.PostPara(r, "email")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid Email")
 		return
@@ -217,13 +217,13 @@ func (h *RegisterHandler) HandleRegisterRequest(w http.ResponseWriter, r *http.R
 		return
 	}
 
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if username == "" || strings.TrimSpace(username) == "" || err != nil {
 		utils.SendErrorResponse(w, "Invalid Username")
 		return
 	}
 
-	password, err := utils.Mv(r, "password", true)
+	password, err := utils.PostPara(r, "password")
 	if password == "" || err != nil {
 		utils.SendErrorResponse(w, "Invalid Password")
 		return
@@ -280,7 +280,7 @@ func (h *RegisterHandler) HandleEmailChange(w http.ResponseWriter, r *http.Reque
 		return
 	}
 
-	email, err := utils.Mv(r, "email", true)
+	email, err := utils.PostPara(r, "email")
 	if err != nil {
 		//Return the user current email
 		currentEmail, _ := h.GetUserEmail(username)

mod/disk/diskcapacity/diskcapacity.go

@@ -48,7 +48,7 @@ func (cr *Resolver) HandleCapacityResolving(w http.ResponseWriter, r *http.Reque
 	}
 
 	//Get vpath from paramter
-	vpath, err := utils.Mv(r, "path", true)
+	vpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Vpath is not defined")
 		return

mod/disk/diskmg/diskmg.go

@@ -72,7 +72,7 @@ var (
 	code and rewriting the whole thing will save you a lot more time.
 */
 func HandleView(w http.ResponseWriter, r *http.Request) {
-	partition, _ := utils.Mv(r, "partition", false)
+	partition, _ := utils.GetPara(r, "partition")
 	detailMode := (partition != "")
 	if runtime.GOOS == "windows" {
 		//Windows. Use DiskmgWin binary
@@ -192,13 +192,13 @@ func HandleView(w http.ResponseWriter, r *http.Request) {
 */
 func HandleMount(w http.ResponseWriter, r *http.Request, fsHandlers []*fs.FileSystemHandler) {
 	if runtime.GOOS == "linux" {
-		targetDev, _ := utils.Mv(r, "dev", false)
-		format, err := utils.Mv(r, "format", false)
+		targetDev, _ := utils.GetPara(r, "dev")
+		format, err := utils.GetPara(r, "format")
 		if err != nil {
 			utils.SendErrorResponse(w, "format not defined")
 			return
 		}
-		mountPt, err := utils.Mv(r, "mnt", false)
+		mountPt, err := utils.GetPara(r, "mnt")
 		if err != nil {
 			utils.SendErrorResponse(w, "Mount Point not defined")
 			return
@@ -234,7 +234,7 @@ func HandleMount(w http.ResponseWriter, r *http.Request, fsHandlers []*fs.FileSy
 		}
 
 		//Check if action is mount or umount
-		umount, _ := utils.Mv(r, "umount", false)
+		umount, _ := utils.GetPara(r, "umount")
 		if umount == "true" {
 			//Unmount the given mountpoint
 			output, err := Unmount(safeMountPoint, fsHandlers)
@@ -265,13 +265,13 @@ func HandleMount(w http.ResponseWriter, r *http.Request, fsHandlers []*fs.FileSy
 
 */
 func HandleFormat(w http.ResponseWriter, r *http.Request, fsHandlers []*fs.FileSystemHandler) {
-	dev, err := utils.Mv(r, "dev", true)
+	dev, err := utils.PostPara(r, "dev")
 	if err != nil {
 		utils.SendErrorResponse(w, "dev not defined")
 		return
 	}
 
-	format, err := utils.Mv(r, "format", true)
+	format, err := utils.PostPara(r, "format")
 	if err != nil {
 		utils.SendErrorResponse(w, "format not defined")
 		return

mod/disk/sortfile/sortfile.go

@@ -32,7 +32,7 @@ func (s *LargeFileScanner) HandleLargeFileList(w http.ResponseWriter, r *http.Re
 	}
 
 	//Check if limit is set. If yes, use the limit in return
-	limit, err := utils.Mv(r, "number", false)
+	limit, err := utils.GetPara(r, "number")
 	if err != nil {
 		limit = "20"
 	}

mod/fileservers/servers/ftpserv/handler.go

@@ -39,7 +39,7 @@ func (m *Manager) HandleFTPServerStatus(w http.ResponseWriter, r *http.Request)
 
 //Update UPnP setting on FTP server
 func (m *Manager) HandleFTPUPnP(w http.ResponseWriter, r *http.Request) {
-	enable, _ := utils.Mv(r, "enable", false)
+	enable, _ := utils.GetPara(r, "enable")
 	if enable == "true" {
 		m.option.Logger.PrintAndLog("FTP", "Enabling UPnP on FTP Server Port", nil)
 		m.option.Sysdb.Write("ftp", "upnp", true)
@@ -58,7 +58,7 @@ func (m *Manager) HandleFTPUPnP(w http.ResponseWriter, r *http.Request) {
 //Update access permission on FTP server
 func (m *Manager) HandleFTPAccessUpdate(w http.ResponseWriter, r *http.Request) {
 	//Get groups paramter from post req
-	groupString, err := utils.Mv(r, "groups", true)
+	groupString, err := utils.PostPara(r, "groups")
 	if err != nil {
 		utils.SendErrorResponse(w, "groups not defined")
 		return
@@ -81,7 +81,7 @@ func (m *Manager) HandleFTPAccessUpdate(w http.ResponseWriter, r *http.Request)
 
 //Handle FTP Set access port
 func (m *Manager) HandleFTPSetPort(w http.ResponseWriter, r *http.Request) {
-	port, err := utils.Mv(r, "port", true)
+	port, err := utils.PostPara(r, "port")
 	if err != nil {
 		utils.SendErrorResponse(w, "Port not defined")
 		return
@@ -111,7 +111,7 @@ func (m *Manager) HandleFTPSetPort(w http.ResponseWriter, r *http.Request) {
 	set=mode&passive=true
 */
 func (m *Manager) HandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Request) {
-	set, err := utils.Mv(r, "set", true)
+	set, err := utils.PostPara(r, "set")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid set type")
 		return
@@ -119,7 +119,7 @@ func (m *Manager) HandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Re
 
 	if set == "ip" {
 		//Update the public up addr
-		ip, err := utils.Mv(r, "ip", true)
+		ip, err := utils.PostPara(r, "ip")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid ip given")
 			return
@@ -129,7 +129,7 @@ func (m *Manager) HandleFTPPassiveModeSettings(w http.ResponseWriter, r *http.Re
 
 	} else if set == "mode" {
 		//Update the passive mode setting
-		passive, err := utils.Mv(r, "passive", true)
+		passive, err := utils.PostPara(r, "passive")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid passive option (true/false)")
 			return

mod/fileservers/servers/sftpserv/sftpserv.go

@@ -90,7 +90,7 @@ func (m *Manager) closeInstance() {
 
 //Get or Set listening port for SFTP
 func (m *Manager) HandleListeningPort(w http.ResponseWriter, r *http.Request) {
-	newport, _ := utils.Mv(r, "port", true)
+	newport, _ := utils.PostPara(r, "port")
 	if newport == "" {
 		//Resp with the current operating port
 		js, _ := json.Marshal(m.listeningPort)
@@ -146,7 +146,7 @@ func (m *Manager) HandleGetConnectedClients(w http.ResponseWriter, r *http.Reque
 }
 
 func (m *Manager) HandleToogleUPnP(w http.ResponseWriter, r *http.Request) {
-	enableUpnp, _ := utils.Mv(r, "enabled", true)
+	enableUpnp, _ := utils.PostPara(r, "enabled")
 	if enableUpnp == "" {
 		//Get the current state of Upnp
 		currentEnabled := getUpnPEnabled(m.option.Sysdb)

mod/fileservers/servers/webdavserv/webdavserv.go

@@ -55,7 +55,7 @@ func (m *Manager) HandleStatusChange(w http.ResponseWriter, r *http.Request) {
 	userinfo, _ := m.option.UserHandler.GetUserInfoFromRequest(w, r)
 	isAdmin := userinfo.IsAdmin()
 
-	set, _ := utils.Mv(r, "set", false)
+	set, _ := utils.GetPara(r, "set")
 	if set == "" {
 		//Return the current status
 		results := []bool{m.WebDavHandler.Enabled, isAdmin}

mod/info/logviewer/logviewer.go

@@ -46,13 +46,13 @@ func (v *Viewer) HandleListLog(w http.ResponseWriter, r *http.Request) {
 // Read log of a given catergory and filename
 //Require GET varaible: file and catergory
 func (v *Viewer) HandleReadLog(w http.ResponseWriter, r *http.Request) {
-	filename, err := utils.Mv(r, "file", false)
+	filename, err := utils.GetPara(r, "file")
 	if err != nil {
 		utils.SendErrorResponse(w, "invalid filename given")
 		return
 	}
 
-	catergory, err := utils.Mv(r, "catergory", false)
+	catergory, err := utils.GetPara(r, "catergory")
 	if err != nil {
 		utils.SendErrorResponse(w, "invalid catergory given")
 		return

mod/iot/assits.go

@@ -17,13 +17,13 @@ import (
 
 //Handle the set and get nickname of a particular IoT device
 func (m *Manager) HandleNickName(w http.ResponseWriter, r *http.Request) {
-	opr, err := utils.Mv(r, "opr", true)
+	opr, err := utils.PostPara(r, "opr")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid operation mode")
 		return
 	}
 
-	uuid, err := utils.Mv(r, "uuid", true)
+	uuid, err := utils.PostPara(r, "uuid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid uuid given")
 		return
@@ -60,7 +60,7 @@ func (m *Manager) HandleNickName(w http.ResponseWriter, r *http.Request) {
 		}
 	} else if opr == "set" {
 		//Get name from paramter
-		name, err := utils.Mv(r, "name", true)
+		name, err := utils.PostPara(r, "name")
 		if err != nil {
 			utils.SendErrorResponse(w, "No nickname was given to the device")
 			return

mod/iot/handlerManager.go

@@ -77,7 +77,7 @@ func (m *Manager) GetDeviceByID(devid string) *Device {
 
 //Handle listing of all avaible scanner and its stats
 func (m *Manager) HandleIconLoad(w http.ResponseWriter, r *http.Request) {
-	devid, err := utils.Mv(r, "devid", false)
+	devid, err := utils.GetPara(r, "devid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid device id")
 		return
@@ -98,19 +98,19 @@ func (m *Manager) HandleIconLoad(w http.ResponseWriter, r *http.Request) {
 
 //Handle listing of all avaible scanner and its stats
 func (m *Manager) HandleExecute(w http.ResponseWriter, r *http.Request) {
-	devid, err := utils.Mv(r, "devid", true)
+	devid, err := utils.PostPara(r, "devid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid device id")
 		return
 	}
 
-	eptname, err := utils.Mv(r, "eptname", true)
+	eptname, err := utils.PostPara(r, "eptname")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid endpoint name")
 		return
 	}
 
-	payload, _ := utils.Mv(r, "payload", true)
+	payload, _ := utils.PostPara(r, "payload")
 
 	//Get device by device id
 	dev := m.GetDeviceByID(devid)
@@ -144,7 +144,7 @@ func (m *Manager) HandleExecute(w http.ResponseWriter, r *http.Request) {
 
 //Get status of the given device ID
 func (m *Manager) HandleGetDeviceStatus(w http.ResponseWriter, r *http.Request) {
-	devid, err := utils.Mv(r, "devid", true)
+	devid, err := utils.PostPara(r, "devid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid device id")
 		return

mod/modules/module.go

@@ -111,9 +111,9 @@ func (m *ModuleHandler) GetModuleNameList() []string {
 //Handle Default Launcher
 func (m *ModuleHandler) HandleDefaultLauncher(w http.ResponseWriter, r *http.Request) {
 	username, _ := m.userHandler.GetAuthAgent().GetUserName(w, r)
-	opr, _ := utils.Mv(r, "opr", false) //Operation, accept {get, set, launch}
-	ext, _ := utils.Mv(r, "ext", false)
-	moduleName, _ := utils.Mv(r, "module", false)
+	opr, _ := utils.GetPara(r, "opr") //Operation, accept {get, set, launch}
+	ext, _ := utils.GetPara(r, "ext")
+	moduleName, _ := utils.GetPara(r, "module")
 
 	ext = strings.ToLower(ext)
 
@@ -226,7 +226,7 @@ func (m *ModuleHandler) GetModuleInfoByID(moduleid string) *ModuleInfo {
 }
 
 func (m *ModuleHandler) GetLaunchParameter(w http.ResponseWriter, r *http.Request) {
-	moduleName, _ := utils.Mv(r, "module", false)
+	moduleName, _ := utils.GetPara(r, "module")
 	if moduleName == "" {
 		utils.SendErrorResponse(w, "Missing paramter 'module'.")
 		return

mod/network/neighbour/handler.go

@@ -60,7 +60,7 @@ func (d *Discoverer) HandleScanRecord(w http.ResponseWriter, r *http.Request) {
 
 //Send wake on land to target
 func (d *Discoverer) HandleWakeOnLan(w http.ResponseWriter, r *http.Request) {
-	mac, err := utils.Mv(r, "mac", false)
+	mac, err := utils.GetPara(r, "mac")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid mac address")
 		return

mod/permission/request.go

@@ -21,7 +21,7 @@ import (
 
 //Handle group editing operations
 func (h *PermissionHandler) HandleListGroup(w http.ResponseWriter, r *http.Request) {
-	listPermission, _ := utils.Mv(r, "showper", false)
+	listPermission, _ := utils.GetPara(r, "showper")
 	if listPermission == "" {
 		//Only show the user group name
 		results := []string{}
@@ -47,16 +47,16 @@ func (h *PermissionHandler) HandleListGroup(w http.ResponseWriter, r *http.Reque
 
 //Listing a group's detail for editing or updating the group content
 func (h *PermissionHandler) HandleGroupEdit(w http.ResponseWriter, r *http.Request) {
-	groupname, err := utils.Mv(r, "groupname", true)
+	groupname, err := utils.PostPara(r, "groupname")
 	if err != nil {
 		utils.SendErrorResponse(w, "Group name not defined")
 		return
 	}
 
-	listmode, _ := utils.Mv(r, "list", false)
+	listmode, _ := utils.GetPara(r, "list")
 	if listmode == "" {
 		//Edit update mode
-		permission, err := utils.Mv(r, "permission", true)
+		permission, err := utils.PostPara(r, "permission")
 		if err != nil {
 			utils.SendErrorResponse(w, "Group name not defined")
 			return
@@ -69,7 +69,7 @@ func (h *PermissionHandler) HandleGroupEdit(w http.ResponseWriter, r *http.Reque
 			return
 		}
 
-		isAdmin, err := utils.Mv(r, "isAdmin", true)
+		isAdmin, err := utils.PostPara(r, "isAdmin")
 		if err != nil {
 			utils.SendErrorResponse(w, "Admin permission not defined")
 			return
@@ -81,13 +81,13 @@ func (h *PermissionHandler) HandleGroupEdit(w http.ResponseWriter, r *http.Reque
 			return
 		}
 
-		quota, err := utils.Mv(r, "defaultQuota", true)
+		quota, err := utils.PostPara(r, "defaultQuota")
 		if err != nil {
 			utils.SendErrorResponse(w, "Default Quota not defined")
 			return
 		}
 
-		interfaceModule, err := utils.Mv(r, "interfaceModule", true)
+		interfaceModule, err := utils.PostPara(r, "interfaceModule")
 		if err != nil {
 			utils.SendErrorResponse(w, "Default Interface Module not defined")
 			return
@@ -128,13 +128,13 @@ func (h *PermissionHandler) HandleGroupEdit(w http.ResponseWriter, r *http.Reque
 }
 
 func (h *PermissionHandler) HandleGroupCreate(w http.ResponseWriter, r *http.Request) {
-	groupname, err := utils.Mv(r, "groupname", true)
+	groupname, err := utils.PostPara(r, "groupname")
 	if err != nil {
 		utils.SendErrorResponse(w, "Group name not defined")
 		return
 	}
 
-	permission, err := utils.Mv(r, "permission", true)
+	permission, err := utils.PostPara(r, "permission")
 	if err != nil {
 		utils.SendErrorResponse(w, "Group name not defined")
 		return
@@ -147,19 +147,19 @@ func (h *PermissionHandler) HandleGroupCreate(w http.ResponseWriter, r *http.Req
 		return
 	}
 
-	isAdmin, err := utils.Mv(r, "isAdmin", true)
+	isAdmin, err := utils.PostPara(r, "isAdmin")
 	if err != nil {
 		utils.SendErrorResponse(w, "Admin permission not defined")
 		return
 	}
 
-	quota, err := utils.Mv(r, "defaultQuota", true)
+	quota, err := utils.PostPara(r, "defaultQuota")
 	if err != nil {
 		utils.SendErrorResponse(w, "Default Quota not defined")
 		return
 	}
 
-	interfaceModule, err := utils.Mv(r, "interfaceModule", true)
+	interfaceModule, err := utils.PostPara(r, "interfaceModule")
 	if err != nil {
 		utils.SendErrorResponse(w, "Default Interface Module not defined")
 		return
@@ -201,7 +201,7 @@ func (h *PermissionHandler) HandleGroupCreate(w http.ResponseWriter, r *http.Req
 }
 
 func (h *PermissionHandler) HandleGroupRemove(w http.ResponseWriter, r *http.Request) {
-	groupname, err := utils.Mv(r, "groupname", true)
+	groupname, err := utils.PostPara(r, "groupname")
 	if err != nil {
 		utils.SendErrorResponse(w, "Group name not defined")
 		return

mod/security/csrf/handlers.go

@@ -26,7 +26,7 @@ func (m *TokenManager) HandleTokenValidation(w http.ResponseWriter, r *http.Requ
 		return false
 	}
 
-	token, _ := utils.Mv(r, "csrft", true)
+	token, _ := utils.PostPara(r, "csrft")
 	if token == "" {
 		return false
 	} else {

mod/share/share.go

@@ -269,7 +269,7 @@ func (s *Manager) HandleShareAccess(w http.ResponseWriter, r *http.Request) {
 	directServe := false
 	relpath := ""
 
-	id, err := utils.Mv(r, "id", false)
+	id, err := utils.GetPara(r, "id")
 	if err != nil {
 		//ID is not defined in the URL paramter. New ID defination is based on the subpath content
 		requestURI := filepath.ToSlash(filepath.Clean(r.URL.Path))
@@ -347,17 +347,17 @@ func (s *Manager) HandleShareAccess(w http.ResponseWriter, r *http.Request) {
 	} else {
 
 		//Parse and redirect to new share path
-		download, _ := utils.Mv(r, "download", false)
+		download, _ := utils.GetPara(r, "download")
 		if download == "true" {
 			directDownload = true
 		}
 
-		serve, _ := utils.Mv(r, "serve", false)
+		serve, _ := utils.GetPara(r, "serve")
 		if serve == "true" {
 			directServe = true
 		}
 
-		relpath, _ = utils.Mv(r, "rel", false)
+		relpath, _ = utils.GetPara(r, "rel")
 
 		redirectURL := "./" + id + "/"
 		if directDownload == true {
@@ -886,7 +886,7 @@ func (s *Manager) HandleShareAccess(w http.ResponseWriter, r *http.Request) {
 //Check if a file is shared
 func (s *Manager) HandleShareCheck(w http.ResponseWriter, r *http.Request) {
 	//Get the vpath from paramters
-	vpath, err := utils.Mv(r, "path", true)
+	vpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid path given")
 		return
@@ -935,7 +935,7 @@ func (s *Manager) HandleShareCheck(w http.ResponseWriter, r *http.Request) {
 //Create new share from the given path
 func (s *Manager) HandleCreateNewShare(w http.ResponseWriter, r *http.Request) {
 	//Get the vpath from paramters
-	vpath, err := utils.Mv(r, "path", true)
+	vpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid path given")
 		return
@@ -981,13 +981,13 @@ func (s *Manager) HandleEditShare(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	uuid, err := utils.Mv(r, "uuid", true)
+	uuid, err := utils.PostPara(r, "uuid")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid path given")
 		return
 	}
 
-	shareMode, _ := utils.Mv(r, "mode", true)
+	shareMode, _ := utils.PostPara(r, "mode")
 	if shareMode == "" {
 		shareMode = "signedin"
 	}
@@ -1052,10 +1052,10 @@ func (s *Manager) HandleDeleteShare(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get the vpath from paramters
-	uuid, err := utils.Mv(r, "uuid", true)
+	uuid, err := utils.PostPara(r, "uuid")
 	if err != nil {
 		//Try to get it from vpath
-		vpath, err := utils.Mv(r, "vpath", true)
+		vpath, err := utils.PostPara(r, "vpath")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid uuid or vpath given")
 			return
@@ -1085,7 +1085,7 @@ func (s *Manager) HandleListAllShares(w http.ResponseWriter, r *http.Request) {
 		utils.SendErrorResponse(w, "User not logged in")
 		return
 	}
-	fshId, _ := utils.Mv(r, "fsh", false)
+	fshId, _ := utils.GetPara(r, "fsh")
 	results := []*shareEntry.ShareOption{}
 	if fshId == "" {
 		//List all

mod/storage/webdav/webdav.go

@@ -89,13 +89,13 @@ func (s *Server) HandleClearAllPending(w http.ResponseWriter, r *http.Request) {
 
 //Handle allow and remove permission of a windows WebDAV Client
 func (s *Server) HandlePermissionEdit(w http.ResponseWriter, r *http.Request) {
-	opr, err := utils.Mv(r, "opr", true)
+	opr, err := utils.PostPara(r, "opr")
 	if err != nil {
 		sendErrorResponse(w, "Invalid operations")
 		return
 	}
 
-	uuid, err := utils.Mv(r, "uuid", true)
+	uuid, err := utils.PostPara(r, "uuid")
 	if err != nil {
 		sendErrorResponse(w, "Invalid uuid")
 		return
@@ -148,7 +148,7 @@ func (s *Server) HandlePermissionEdit(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) HandleConnectionList(w http.ResponseWriter, r *http.Request) {
-	target, _ := utils.Mv(r, "target", false)
+	target, _ := utils.GetPara(r, "target")
 	results := []*WindowClientInfo{}
 	if target == "" {
 		//List not logged in clients

mod/time/scheduler/handlers.go

@@ -22,7 +22,7 @@ func (a *Scheduler) HandleListJobs(w http.ResponseWriter, r *http.Request) {
 
 	//Check if the user request list all
 	listAll := false
-	la, _ := utils.Mv(r, "listall", false)
+	la, _ := utils.GetPara(r, "listall")
 	if la == "true" && userinfo.IsAdmin() {
 		listAll = true
 	}
@@ -56,7 +56,7 @@ func (a *Scheduler) HandleAddJob(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get required paramaters
-	taskName, err := utils.Mv(r, "name", true)
+	taskName, err := utils.PostPara(r, "name")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid task name")
 		return
@@ -76,14 +76,14 @@ func (a *Scheduler) HandleAddJob(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	scriptpath, err := utils.Mv(r, "path", true)
+	scriptpath, err := utils.PostPara(r, "path")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid script path")
 		return
 	}
 
 	//Can be empty
-	jobDescription, _ := utils.Mv(r, "desc", true)
+	jobDescription, _ := utils.PostPara(r, "desc")
 	fsh, err := userinfo.GetFileSystemHandlerFromVirtualPath(scriptpath)
 	if err != nil {
 		utils.SendErrorResponse(w, err.Error())
@@ -103,7 +103,7 @@ func (a *Scheduler) HandleAddJob(w http.ResponseWriter, r *http.Request) {
 	}
 
 	interval := int64(86400) //default 1 day in seconds
-	intervalString, err := utils.Mv(r, "interval", true)
+	intervalString, err := utils.PostPara(r, "interval")
 	if err != nil {
 		//Default 1 day
 
@@ -120,7 +120,7 @@ func (a *Scheduler) HandleAddJob(w http.ResponseWriter, r *http.Request) {
 	}
 
 	baseUnixTime := time.Now().Unix()
-	baseTimeString, err := utils.Mv(r, "base", true)
+	baseTimeString, err := utils.PostPara(r, "base")
 	if err != nil {
 		//Use curent timestamp as base
 
@@ -162,7 +162,7 @@ func (a *Scheduler) HandleJobRemoval(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get required paramaters
-	taskName, err := utils.Mv(r, "name", true)
+	taskName, err := utils.PostPara(r, "name")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid task name")
 		return
@@ -203,7 +203,7 @@ func (a *Scheduler) HandleJobRemoval(w http.ResponseWriter, r *http.Request) {
 //Deprecated. Replace with system wide logger
 /*
 func (a *Scheduler) HandleShowLog(w http.ResponseWriter, r *http.Request) {
-	filename, _ := utils.Mv(r, "filename", false)
+	filename, _ := utils.GetPara(r,"filename")
 	if filename == "" {
 		//Show index
 		logFiles, _ := filepath.Glob(logFolder + "*.log")

mod/updates/handler.go

@@ -45,13 +45,13 @@ type UpdateConfig struct {
 }
 
 func HandleUpdateCheckSize(w http.ResponseWriter, r *http.Request) {
-	webpack, err := utils.Mv(r, "webpack", true)
+	webpack, err := utils.PostPara(r, "webpack")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid or empty webpack download URL")
 		return
 	}
 
-	binary, err := utils.Mv(r, "binary", true)
+	binary, err := utils.PostPara(r, "binary")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid or empty binary download URL")
 		return
@@ -68,25 +68,25 @@ func HandleUpdateCheckSize(w http.ResponseWriter, r *http.Request) {
 }
 
 func HandleUpdateDownloadRequest(w http.ResponseWriter, r *http.Request) {
-	webpack, err := utils.Mv(r, "webpack", false)
+	webpack, err := utils.GetPara(r, "webpack")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid or empty webpack download URL")
 		return
 	}
 
-	binary, err := utils.Mv(r, "binary", false)
+	binary, err := utils.GetPara(r, "binary")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid or empty binary download URL")
 		return
 	}
 
-	checksum, err := utils.Mv(r, "checksum", true)
+	checksum, err := utils.PostPara(r, "checksum")
 	if err != nil {
 		checksum = ""
 	}
 
 	//Update the connection to websocket
-	requireWebsocket, _ := utils.Mv(r, "ws", false)
+	requireWebsocket, _ := utils.GetPara(r, "ws")
 	if requireWebsocket == "true" {
 		//Upgrade to websocket
 		var upgrader = websocket.Upgrader{}

mod/utils/utils.go

@@ -52,6 +52,7 @@ func SendOK(w http.ResponseWriter) {
 	Error (if error)
 
 */
+/*
 func Mv(r *http.Request, getParamter string, postMode bool) (string, error) {
 	if postMode == false {
 		//Access the paramter via GET
@@ -77,6 +78,28 @@ func Mv(r *http.Request, getParamter string, postMode bool) (string, error) {
 	}
 
 }
+*/
+
+//Get GET parameter
+func GetPara(r *http.Request, key string) (string, error) {
+	keys, ok := r.URL.Query()[key]
+	if !ok || len(keys[0]) < 1 {
+		return "", errors.New("invalid " + key + " given")
+	} else {
+		return keys[0], nil
+	}
+}
+
+//Get POST paramter
+func PostPara(r *http.Request, key string) (string, error) {
+	r.ParseForm()
+	x := r.Form.Get(key)
+	if x == "" {
+		return "", errors.New("invalid " + key + " given")
+	} else {
+		return x, nil
+	}
+}
 
 func FileExists(filename string) bool {
 	_, err := os.Stat(filename)

mod/www/handler.go

@@ -44,7 +44,7 @@ func (h *Handler) HandleToggleHomepage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	set, _ := utils.Mv(r, "set", true)
+	set, _ := utils.PostPara(r, "set")
 	if set == "" {
 		//Read mode
 		result := h.CheckUserHomePageEnabled(userinfo.Username)
@@ -72,7 +72,7 @@ func (h *Handler) HandleSetWebRoot(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	set, _ := utils.Mv(r, "set", true)
+	set, _ := utils.PostPara(r, "set")
 	if set == "" {
 		//Read mode
 		webroot, err := h.GetUserWebRoot(userinfo.Username)

module.go

@@ -55,7 +55,7 @@ func ModuleServiceInit() {
 		//Validate the user is admin
 		if userinfo.IsAdmin() {
 			//Get the installation file path
-			installerPath, err := utils.Mv(r, "path", true)
+			installerPath, err := utils.PostPara(r, "path")
 			if err != nil {
 				utils.SendErrorResponse(w, "Invalid installer path")
 				return
@@ -151,11 +151,11 @@ func ModuleInstallerInit() {
 
 //Handle module installation request
 func HandleModuleInstall(w http.ResponseWriter, r *http.Request) {
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 
 	if opr == "gitinstall" {
 		//Get URL from request
-		url, _ := utils.Mv(r, "url", true)
+		url, _ := utils.PostPara(r, "url")
 		if url == "" {
 			utils.SendErrorResponse(w, "Invalid URL")
 			return
@@ -174,7 +174,7 @@ func HandleModuleInstall(w http.ResponseWriter, r *http.Request) {
 
 	} else if opr == "remove" {
 		//Get the module name from list
-		module, _ := utils.Mv(r, "module", true)
+		module, _ := utils.PostPara(r, "module")
 		if module == "" {
 			utils.SendErrorResponse(w, "Invalid Module Name")
 			return

network.forward.go

@@ -63,7 +63,7 @@ func portForwardInit() {
 }
 
 func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 	if opr == "" {
 		if UPNP == nil {
 			utils.SendErrorResponse(w, "UPNP is not enabled")
@@ -103,7 +103,7 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 		js, _ := json.Marshal(forwardPorts)
 		utils.SendJSONResponse(w, string(js))
 	} else if opr == "add" {
-		port, err := utils.Mv(r, "port", true)
+		port, err := utils.PostPara(r, "port")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid port number")
 			return
@@ -117,7 +117,7 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 		}
 
 		//Get the policy name
-		policyName, err := utils.Mv(r, "name", true)
+		policyName, err := utils.PostPara(r, "name")
 		if err != nil {
 			policyName = "Unnamed Forward Policy"
 		}
@@ -138,7 +138,7 @@ func portforward_handleForward(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 	} else if opr == "remove" {
-		port, err := utils.Mv(r, "port", true)
+		port, err := utils.PostPara(r, "port")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid port number")
 			return

network.go

@@ -381,13 +381,13 @@ func FileServerInit() {
 
 //Toggle the target File Server Services
 func NetworkHandleFileServerToggle(w http.ResponseWriter, r *http.Request) {
-	servid, err := utils.Mv(r, "id", true)
+	servid, err := utils.PostPara(r, "id")
 	if err != nil {
 		utils.SendErrorResponse(w, "invalid service id given")
 		return
 	}
 
-	newState, err := utils.Mv(r, "enable", true)
+	newState, err := utils.PostPara(r, "enable")
 	if err != nil {
 		utils.SendErrorResponse(w, "undefined enable state")
 		return
@@ -427,7 +427,7 @@ func NetworkHandleGetFileServerServiceList(w http.ResponseWriter, r *http.Reques
 
 //Get the status of a file server type.
 func NetworkHandleGetFileServerStatus(w http.ResponseWriter, r *http.Request) {
-	servid, _ := utils.Mv(r, "id", false)
+	servid, _ := utils.GetPara(r, "id")
 	if servid == "" {
 		//List all state in map
 		result := map[string]bool{}
@@ -458,7 +458,7 @@ func NetworkHandleGetFileServerEndpoints(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	targetServerTypeID, _ := utils.Mv(r, "fserv", false)
+	targetServerTypeID, _ := utils.GetPara(r, "fserv")
 	targetServerTypeID = strings.TrimSpace(targetServerTypeID)
 
 	if targetServerTypeID == "" {

quota.go

@@ -57,13 +57,13 @@ func system_disk_quota_setQuota(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	groupname, err := utils.Mv(r, "groupname", true)
+	groupname, err := utils.PostPara(r, "groupname")
 	if err != nil {
 		utils.SendErrorResponse(w, "Group name not defned")
 		return
 	}
 
-	quotaSizeString, err := utils.Mv(r, "quota", true)
+	quotaSizeString, err := utils.PostPara(r, "quota")
 	if err != nil {
 		utils.SendErrorResponse(w, "Quota not defined")
 		return

register.go

@@ -92,7 +92,7 @@ func register_handleEmailListing(w http.ResponseWriter, r *http.Request) {
 	//Get all user emails from the registerHandler
 	userRegisterInfos := registerHandler.ListAllUserEmails()
 
-	useCSV, _ := utils.Mv(r, "csv", false)
+	useCSV, _ := utils.GetPara(r, "csv")
 	if useCSV == "true" {
 		//Prase as csv
 		csvString := "Username,Email,Still Registered\n"
@@ -117,13 +117,13 @@ func register_handleEmailListing(w http.ResponseWriter, r *http.Request) {
 }
 
 func register_handleSetDefaultGroup(w http.ResponseWriter, r *http.Request) {
-	getDefaultGroup, _ := utils.Mv(r, "get", true)
+	getDefaultGroup, _ := utils.PostPara(r, "get")
 	if getDefaultGroup == "true" {
 		jsonString, _ := json.Marshal(registerHandler.DefaultUserGroup)
 		utils.SendJSONResponse(w, string(jsonString))
 		return
 	}
-	newDefaultGroup, err := utils.Mv(r, "defaultGroup", true)
+	newDefaultGroup, err := utils.PostPara(r, "defaultGroup")
 	if err != nil {
 		utils.SendErrorResponse(w, "defaultGroup not defined")
 		return
@@ -142,7 +142,7 @@ func register_handleGetAllowRegistry(w http.ResponseWriter, r *http.Request) {
 }
 
 func register_handleToggleRegistry(w http.ResponseWriter, r *http.Request) {
-	allowReg, err := utils.Mv(r, "allow", true)
+	allowReg, err := utils.PostPara(r, "allow")
 	if err != nil {
 		allowReg = "false"
 	}

setting.go

@@ -127,7 +127,7 @@ func system_setting_handleListing(w http.ResponseWriter, r *http.Request) {
 	}
 
 	allSettingGroups := system_setting_getSettingGroups()
-	listGroup, _ := utils.Mv(r, "listGroup", false)
+	listGroup, _ := utils.GetPara(r, "listGroup")
 	if len(listGroup) > 0 {
 		//List the given group
 		var results []settingModule

startup.flags.go

@@ -49,7 +49,7 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 		EnableHomePage    bool
 		EnableDirListing  bool
 	}
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 	if opr == "" {
 		//List the current boot flag, all units in MB
 		js, _ := json.Marshal(bootFlags{
@@ -65,7 +65,7 @@ func handleBootFlagsFunction(w http.ResponseWriter, r *http.Request) {
 		utils.SendJSONResponse(w, string(js))
 	} else if opr == "set" {
 		//Set and update the boot flags
-		newSettings, err := utils.Mv(r, "value", true)
+		newSettings, err := utils.PostPara(r, "value")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid new seting value")
 			return

storage.pool.go

@@ -62,15 +62,15 @@ func StoragePoolEditorInit() {
 
 //Handle editing of a given File System Handler
 func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
-	opr, _ := utils.Mv(r, "opr", true)
-	group, err := utils.Mv(r, "group", true)
+	opr, _ := utils.PostPara(r, "opr")
+	group, err := utils.PostPara(r, "group")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid group given")
 		return
 	}
 
 	if opr == "get" {
-		uuid, err := utils.Mv(r, "uuid", true)
+		uuid, err := utils.PostPara(r, "uuid")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid UUID")
 			return
@@ -91,7 +91,7 @@ func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
 		utils.SendJSONResponse(w, string(js))
 		return
 	} else if opr == "set" {
-		config, err := utils.Mv(r, "config", true)
+		config, err := utils.PostPara(r, "config")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid UUID")
 			return
@@ -115,7 +115,7 @@ func HandleFSHEdit(w http.ResponseWriter, r *http.Request) {
 		}
 	} else if opr == "new" {
 		//New handler
-		config, err := utils.Mv(r, "config", true)
+		config, err := utils.PostPara(r, "config")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid config")
 			return
@@ -276,13 +276,13 @@ func setFSHConfigByGroupAndId(group string, uuid string, options fs.FileSystemOp
 
 //Handle Storage Pool toggle on-off
 func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
-	fsh, _ := utils.Mv(r, "fsh", true)
+	fsh, _ := utils.PostPara(r, "fsh")
 	if fsh == "" {
 		utils.SendErrorResponse(w, "Invalid File System Handler ID")
 		return
 	}
 
-	group, _ := utils.Mv(r, "group", true)
+	group, _ := utils.PostPara(r, "group")
 	if group == "" {
 		utils.SendErrorResponse(w, "Invalid group ID")
 		return
@@ -350,7 +350,7 @@ func HandleFSHToggle(w http.ResponseWriter, r *http.Request) {
 
 //Handle reload of storage pool
 func HandleStoragePoolReload(w http.ResponseWriter, r *http.Request) {
-	pool, _ := utils.Mv(r, "pool", true)
+	pool, _ := utils.PostPara(r, "pool")
 
 	//Basepool super long string just to prevent any typo
 	if pool == "1eb201a3-d0f6-6630-5e6d-2f40480115c5" {
@@ -435,13 +435,13 @@ func HandleStoragePoolReload(w http.ResponseWriter, r *http.Request) {
 }
 
 func HandleStoragePoolRemove(w http.ResponseWriter, r *http.Request) {
-	groupname, err := utils.Mv(r, "group", true)
+	groupname, err := utils.PostPara(r, "group")
 	if err != nil {
 		utils.SendErrorResponse(w, "group not defined")
 		return
 	}
 
-	uuid, err := utils.Mv(r, "uuid", true)
+	uuid, err := utils.PostPara(r, "uuid")
 	if err != nil {
 		utils.SendErrorResponse(w, "File system handler UUID not defined")
 		return
@@ -602,7 +602,7 @@ func HandleStorageNewFsHandler(w http.ResponseWriter, r *http.Request) {
 */
 
 func HandleListStoragePoolsConfig(w http.ResponseWriter, r *http.Request) {
-	target, _ := utils.Mv(r, "target", false)
+	target, _ := utils.GetPara(r, "target")
 	if target == "" {
 		target = "system"
 	}
@@ -635,7 +635,7 @@ func HandleListStoragePoolsConfig(w http.ResponseWriter, r *http.Request) {
 
 //Return all storage pool mounted to the system, aka base pool + pg pools
 func HandleListStoragePools(w http.ResponseWriter, r *http.Request) {
-	filter, _ := utils.Mv(r, "filter", false)
+	filter, _ := utils.GetPara(r, "filter")
 
 	storagePools := []*storage.StoragePool{}
 
@@ -666,7 +666,7 @@ func HandleListStoragePools(w http.ResponseWriter, r *http.Request) {
 //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 := utils.Mv(r, "base", true)
+	basePool, err := utils.PostPara(r, "base")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid base pool")
 		return
@@ -680,7 +680,7 @@ func HandleFSHBridging(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	targetFSH, err := utils.Mv(r, "fsh", true)
+	targetFSH, err := utils.PostPara(r, "fsh")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid File System Handler given")
 		return
@@ -713,13 +713,13 @@ func HandleFSHBridging(w http.ResponseWriter, r *http.Request) {
 }
 
 func HandleFSHBridgeCheck(w http.ResponseWriter, r *http.Request) {
-	basePool, err := utils.Mv(r, "base", true)
+	basePool, err := utils.PostPara(r, "base")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid base pool")
 		return
 	}
 
-	fsh, err := utils.Mv(r, "fsh", true)
+	fsh, err := utils.PostPara(r, "fsh")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid fsh UUID")
 		return

system.info.go

@@ -146,7 +146,7 @@ func SystemInfoInit() {
 					utils.SendErrorResponse(w, err.Error())
 					return
 				}
-				execute, _ := utils.Mv(r, "exec", true)
+				execute, _ := utils.PostPara(r, "exec")
 				if execute == "true" && r.Method == http.MethodPost {
 					//Do the update
 					systemWideLogger.PrintAndLog("System", "REQUESTING LAUNCHER FOR UPDATE RESTART", nil)

system.resetpw.go

@@ -22,12 +22,12 @@ func system_resetpw_init() {
 
 //Validate if the ysername and rkey is valid
 func system_resetpw_validateResetKeyHandler(w http.ResponseWriter, r *http.Request) {
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid username or key")
 		return
 	}
-	rkey, err := utils.Mv(r, "rkey", true)
+	rkey, err := utils.PostPara(r, "rkey")
 	if err != nil {
 		utils.SendErrorResponse(w, "Invalid username or key")
 		return
@@ -50,9 +50,9 @@ func system_resetpw_validateResetKeyHandler(w http.ResponseWriter, r *http.Reque
 }
 
 func system_resetpw_confirmReset(w http.ResponseWriter, r *http.Request) {
-	username, _ := utils.Mv(r, "username", true)
-	rkey, _ := utils.Mv(r, "rkey", true)
-	newpw, _ := utils.Mv(r, "pw", true)
+	username, _ := utils.PostPara(r, "username")
+	rkey, _ := utils.PostPara(r, "rkey")
+	newpw, _ := utils.PostPara(r, "pw")
 	if username == "" || rkey == "" || newpw == "" {
 		utils.SendErrorResponse(w, "Internal Server Error")
 		return
@@ -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 := utils.Mv(r, "acc", false)
+	acc, err := utils.GetPara(r, "acc")
 	if err != nil || acc == "" {
 		system_resetpw_serveIdEnterInterface(w, r)
 		return
 	}
 
-	resetkey, err := utils.Mv(r, "rkey", false)
+	resetkey, err := utils.GetPara(r, "rkey")
 	if err != nil || resetkey == "" {
 		system_resetpw_serveIdEnterInterface(w, r)
 		return

user.go

@@ -90,7 +90,7 @@ func UserSystemInit() {
 
 //Remove a user from the system
 func user_handleUserRemove(w http.ResponseWriter, r *http.Request) {
-	username, err := utils.Mv(r, "username", true)
+	username, err := utils.PostPara(r, "username")
 	if err != nil {
 		utils.SendErrorResponse(w, "Username not defined")
 		return
@@ -142,8 +142,8 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	opr, _ := utils.Mv(r, "opr", true)
-	username, _ := utils.Mv(r, "username", true)
+	opr, _ := utils.PostPara(r, "opr")
+	username, _ := utils.PostPara(r, "username")
 	if !authAgent.UserExists(username) {
 		utils.SendErrorResponse(w, "User not exists")
 		return
@@ -183,14 +183,14 @@ func user_handleUserEdit(w http.ResponseWriter, r *http.Request) {
 		utils.SendJSONResponse(w, string(jsonString))
 	} else if opr == "updateUserGroup" {
 		//Update the target user's group
-		newgroup, err := utils.Mv(r, "newgroup", true)
+		newgroup, err := utils.PostPara(r, "newgroup")
 		if err != nil {
 			systemWideLogger.PrintAndLog("User", err.Error(), err)
 			utils.SendErrorResponse(w, "New Group not defined")
 			return
 		}
 
-		newQuota, err := utils.Mv(r, "quota", true)
+		newQuota, err := utils.PostPara(r, "quota")
 		if err != nil {
 			systemWideLogger.PrintAndLog("User", err.Error(), err)
 			utils.SendErrorResponse(w, "Quota not defined")
@@ -305,7 +305,7 @@ func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		utils.SendErrorResponse(w, "User not logged in")
 		return
 	}
-	opr, _ := utils.Mv(r, "opr", true)
+	opr, _ := utils.PostPara(r, "opr")
 
 	if opr == "" {
 		//Listing mode
@@ -334,8 +334,8 @@ func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		utils.SendJSONResponse(w, string(jsonString))
 		return
 	} else if opr == "changepw" {
-		oldpw, _ := utils.Mv(r, "oldpw", true)
-		newpw, _ := utils.Mv(r, "newpw", true)
+		oldpw, _ := utils.PostPara(r, "oldpw")
+		newpw, _ := utils.PostPara(r, "newpw")
 		if oldpw == "" || newpw == "" {
 			utils.SendErrorResponse(w, "Password cannot be empty")
 			return
@@ -354,7 +354,7 @@ func user_handleUserInfo(w http.ResponseWriter, r *http.Request) {
 		sysdb.Write("auth", "passhash/"+username, newHashedPassword)
 		utils.SendOK(w)
 	} else if opr == "changeprofilepic" {
-		picdata, _ := utils.Mv(r, "picdata", true)
+		picdata, _ := utils.PostPara(r, "picdata")
 		if picdata != "" {
 			setUserIcon(username, picdata)
 			utils.SendOK(w)

wifi.go

@@ -86,7 +86,7 @@ func network_wifi_handleWiFiPower(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	status, _ := utils.Mv(r, "status", true)
+	status, _ := utils.PostPara(r, "status")
 	if status == "" {
 		//Show current power status
 		infs, err := wifiManager.GetWirelessInterfaces()
@@ -114,7 +114,7 @@ func network_wifi_handleWiFiPower(w http.ResponseWriter, r *http.Request) {
 
 	} else {
 		//Change current power status
-		wlaninterface, err := utils.Mv(r, "interface", true)
+		wlaninterface, err := utils.PostPara(r, "interface")
 		if err != nil {
 			utils.SendErrorResponse(w, "Invalid interface")
 			return
@@ -189,16 +189,16 @@ func network_wifi_handleConnect(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	ssid, err := utils.Mv(r, "ESSID", true)
+	ssid, err := utils.PostPara(r, "ESSID")
 	if err != nil {
 		utils.SendErrorResponse(w, "ESSID not given")
 		return
 	}
-	connType, _ := utils.Mv(r, "ConnType", true)
-	password, _ := utils.Mv(r, "pwd", true)
+	connType, _ := utils.PostPara(r, "ConnType")
+	password, _ := utils.PostPara(r, "pwd")
 	systemWideLogger.PrintAndLog("WiFi", "WiFi Switch Request Received. Genering Network Configuration...", nil)
 
-	identity, err := utils.Mv(r, "identity", true)
+	identity, err := utils.PostPara(r, "identity")
 	if err != nil {
 		identity = ""
 	}
@@ -233,7 +233,7 @@ func network_wifi_handleWiFiRemove(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Get ESSID from post request
-	ESSID, err := utils.Mv(r, "ESSID", true)
+	ESSID, err := utils.PostPara(r, "ESSID")
 	if err != nil {
 		utils.SendErrorResponse(w, "ESSID not given")
 		return