fsconv/main.go

/*
ArOZ Online System - fscov File Naming Format Conversion Tool

This micro-servie is designed to convert filename from and to umfilename (ArOZ Online System File Explorer Custom Format)
and standard UTF-8 File System filename.

Usage:
./fsconv
(Convert all the files, folder and sub-directories from and to umfilename to UTF8 filename.)

./fsconv {target} {mode (um / utf)}
(Convert all the files, folder and sub-directories to filename in given mode, target can be file or directory.)

*/

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"reflect"
	"sort"
	"strings"
	"bytes"
	"encoding/hex"
	"flag"
)

//Commonly used functions
func in_array(val interface{}, array interface{}) (exists bool, index int) {
	exists = false
	index = -1

	switch reflect.TypeOf(array).Kind() {
	case reflect.Slice:
		s := reflect.ValueOf(array)

		for i := 0; i < s.Len(); i++ {
			if reflect.DeepEqual(val, s.Index(i).Interface()) == true {
				index = i
				exists = true
				return
			}
		}
	}

	return
}

func file_exists(path string) bool {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return false
	}
	return true
}

func file_get_contents(path string) string {
	dat, err := ioutil.ReadFile(path)
	if err != nil {
		panic("Unable to read file: " + path)
	}
	return (string(dat))

}

func scan_recursive(dir_path string, ignore []string) ([]string, []string) {

	folders := []string{}
	files := []string{}

	// Scan
	filepath.Walk(dir_path, func(path string, f os.FileInfo, err error) error {

		_continue := false

		// Loop : Ignore Files & Folders
		for _, i := range ignore {

			// If ignored path
			if strings.Index(path, i) != -1 {

				// Continue
				_continue = true
			}
		}

		if _continue == false {

			f, err = os.Stat(path)

			// If no error
			if err != nil {
				panic("ERROR. " + err.Error())
			}

			// File & Folder Mode
			f_mode := f.Mode()

			// Is folder
			if f_mode.IsDir() {

				// Append to Folders Array
				folders = append(folders, path)

				// Is file
			} else if f_mode.IsRegular() {

				// Append to Files Array
				files = append(files, path)
			}
		}

		return nil
	})

	return folders, files
}

func hex2bin(s string) ([]byte, error) {
	ret, err := hex.DecodeString(s)
	return ret, err
}

func bin2hex(s string) (string) {
	src := []byte(s)
	encodedStr := hex.EncodeToString(src)
	return encodedStr;
}

type ByLen []string
 
func (a ByLen) Len() int {
   return len(a)
}
 
func (a ByLen) Less(i, j int) bool {
   return len(a[i]) > len(a[j])
}
 
func (a ByLen) Swap(i, j int) {
   a[i], a[j] = a[j], a[i]
}
 

func main() {
	dir, _ := filepath.Abs(filepath.Dir(os.Args[0]))
	if len(os.Args) < 2 {
		//Default options, usually double click will start this process
		folders, files := scan_recursive(dir, []string{os.Args[0]})
		for i := 0; i < len(files); i++ {
			thisFilepath := strings.ReplaceAll(files[i], "\\", "/")
			filename := path.Base(thisFilepath)
			extension := filepath.Ext(filename)
			name := filename[0 : len(filename)-len(extension)]
			//Check if it has the inith prefix
			if len(name) > 5 && name[0:5] == "inith"{
				//This is hex filename. Translate its name to normal filename
				originalName,_ := hex2bin(name[5:])
				safeName := getSafeFilename(string(originalName))
				fmt.Println(filename + " -> " + safeName + extension)
				err := os.Rename(files[i], path.Dir(thisFilepath) + "/" + safeName + extension)
				if (err != nil){
					panic(err)
				}
			}
			
		}
		
		//Sort the array of folders by string length, hence deeper folder will be renamed first
		sort.Sort(ByLen(folders))
		applicationStartupPath, _ := Realpath(path.Dir(os.Args[0]))
		for j := 0; j < len(folders); j++{
			foldername := path.Base(folders[j])
			if (foldername != applicationStartupPath && len(filepath.Base(foldername)) > 2){
				//All subdirectories except the root
				if (isHex(filepath.Base(foldername))){
					//This folder use hex foldername. Convert it to UTF8 filename
					convFoldername, _ := hex2bin(filepath.Base(foldername));
					safeName := getSafeFilename(string(convFoldername))
					fmt.Println(filepath.Base(foldername) + " -> " + string(safeName))
					os.Rename(foldername,filepath.Dir(foldername) + "/" + string(safeName))
				}
			}
			
		}


	}else if (len(os.Args) == 2 && os.Args[1] == "help"){
		//Show help message
		fmt.Println("ArOZ Online UM File Naming Method Converter")
		fmt.Println("Usage: \n./fsconv						Convert all files under current directory and its sub-directories into UTF-8 file naming method.")
		fmt.Println("./fsconv -um 						Convert all files under current directory and its sub-directories into UM File Naming Method representation.")
		fmt.Println("Flags")
		fmt.Println("-r		Recirsive directory conversion, accept { true / false }")
		fmt.Println("-i		Input file / directory path")
		fmt.Println("-f 	Format, accept { default / umfilename } only")
		fmt.Println("-m 	Conversion Mode, accept { file / folder / all} only")


	}else if (len(os.Args) == 2 && os.Args[1] == "-um"){
		//Convert all files and folder into um filenaming methods
		folders, files := scan_recursive(dir, []string{os.Args[0]})
		for i := 0; i < len(files); i++ {
			thisFilepath := strings.ReplaceAll(files[i], "\\", "/")
			filename := path.Base(thisFilepath)
			extension := filepath.Ext(filename)
			name := filename[0 : len(filename)-len(extension)]
			//Check if it has the inith prefix
			if len(name) > 5 && name[0:5] != "inith"{
				//This is not hex filename. Translate its name to um-filename method
				umfilename := "inith" + bin2hex(name)
				fmt.Println(filename + " -> " + umfilename + extension)
				err := os.Rename(files[i], path.Dir(thisFilepath) + "/" + umfilename + extension)
				if (err != nil){
					panic(err)
				}
			}
			
		}
		
		//Sort the array of folders by string length, hence deeper folder will be renamed first
		sort.Sort(ByLen(folders))
		applicationStartupPath, _ := Realpath(path.Dir(os.Args[0]))
		for j := 0; j < len(folders); j++{
			foldername := path.Base(folders[j])
			if (foldername != applicationStartupPath){
				//All subdirectories except the root
				if (!isHex(filepath.Base(foldername))){
					//This folder do not hex foldername. Convert it to hex-foldername
					convFoldername := bin2hex(filepath.Base(foldername));
					fmt.Println(filepath.Base(foldername) + " -> " + string(convFoldername))
					os.Rename(foldername,filepath.Dir(foldername) + "/" + string(convFoldername))
				}
			}
			
		}
	} else {
		//Given target directory with flags
		var recursive = flag.Bool("r",false,"Enable recursive filename translation.")
		var inputFile = flag.String("i","","Input filename.")
		var format = flag.String("f","default","Conversion target format. Accept {default/umfilename}.")
		var mode = flag.String("m","all","Conversion mode. Accept {file/folder/all}.")
		flag.Parse()
		fmt.Println("r:", *recursive)
		fmt.Println("i:", *inputFile)
		fmt.Println("f:", *format)
		fmt.Println("m:", *mode)

	}
}



func getSafeFilename(s string) string{
	replacer := strings.NewReplacer("/", "", "\\","", "@","-", "&","-", "*","-", "<","-", ">","-", "|","-", "?","-", ":","-")
	safeName := replacer.Replace(string(s))
	return safeName
}

func isHex(s string) bool{
	_, err := hex2bin(s)
	if err != nil {
		return false
	}
	return true
}


//Realpath from https://github.com/yookoala/realpath/blob/master/realpath.go
// Realpath returns the real path of a given file in the os
func Realpath(fpath string) (string, error) {

	if len(fpath) == 0 {
		return "", os.ErrInvalid
	}

	if !filepath.IsAbs(fpath) {
		pwd, err := os.Getwd()
		if err != nil {
			return "", err
		}
		fpath = filepath.Join(pwd, fpath)
	}

	path := []byte(fpath)
	nlinks := 0
	start := 1
	prev := 1
	for start < len(path) {
		c := nextComponent(path, start)
		cur := c[start:]

		switch {

		case len(cur) == 0:
			copy(path[start:], path[start+1:])
			path = path[0 : len(path)-1]

		case len(cur) == 1 && cur[0] == '.':
			if start+2 < len(path) {
				copy(path[start:], path[start+2:])
			}
			path = path[0 : len(path)-2]

		case len(cur) == 2 && cur[0] == '.' && cur[1] == '.':
			copy(path[prev:], path[start+2:])
			path = path[0 : len(path)+prev-(start+2)]
			prev = 1
			start = 1

		default:

			fi, err := os.Lstat(string(c))
			if err != nil {
				return "", err
			}
			if isSymlink(fi) {

				nlinks++
				if nlinks > 16 {
					return "", os.ErrInvalid
				}

				var link string
				link, err = os.Readlink(string(c))
				after := string(path[len(c):])

				// switch symlink component with its real path
				path = switchSymlinkCom(path, start, link, after)

				prev = 1
				start = 1
			} else {
				// Directories
				prev = start
				start = len(c) + 1
			}
		}
	}

	for len(path) > 1 && path[len(path)-1] == os.PathSeparator {
		path = path[0 : len(path)-1]
	}
	return string(path), nil

}

// test if a link is symbolic link
func isSymlink(fi os.FileInfo) bool {
	return fi.Mode()&os.ModeSymlink == os.ModeSymlink
}

// switch a symbolic link component to its real path
func switchSymlinkCom(path []byte, start int, link, after string) []byte {

	if link[0] == os.PathSeparator {
		// Absolute links
		return []byte(filepath.Join(link, after))
	}

	// Relative links
	return []byte(filepath.Join(string(path[0:start]), link, after))
}

// get the next component
func nextComponent(path []byte, start int) []byte {
	v := bytes.IndexByte(path[start:], os.PathSeparator)
	if v < 0 {
		return path
	}
	return path[0 : start+v]
}