Non Admin User API Implementation

src/fs/auth.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"net/http"
+	"encoding/json"
+	"database/sql"
+	"fmt"
+	"strconv"
+)
+
+func use(h http.HandlerFunc, middleware ...func(http.HandlerFunc) http.HandlerFunc) http.HandlerFunc {
+	for _, m := range middleware {
+		h = m(h)
+	}
+	return h
+}
+
+func (service *MercuryFsService) authenticate(writer http.ResponseWriter, request *http.Request) {
+	decoder := json.NewDecoder(request.Body)
+	data := make(map[string]interface{})
+	err := decoder.Decode(&data)
+	if err != nil {
+		panic(err)
+	}
+	defer request.Body.Close()
+	pin, ok := data["pin"].(string)
+	if !ok {
+		// pin is not a string
+		writer.WriteHeader(http.StatusBadRequest)
+		return
+	}
+	authToken, err := service.Users.queryUser(pin)
+	switch {
+	case err == sql.ErrNoRows:
+		log("No user with pin: %s", pin)
+		http.Error(writer, "Authentication Failed", http.StatusUnauthorized)
+		break
+	case err != nil:
+		http.Error(writer, "Internal Server Error", http.StatusInternalServerError)
+		log(err.Error())
+		break
+	default:
+		respJson := fmt.Sprintf("{\"auth_token\": \"%s\"}", *authToken)
+		writer.WriteHeader(http.StatusOK)
+		size := int64(len(respJson))
+		writer.Header().Set("Content-Length", strconv.FormatInt(size, 10))
+		writer.Header().Set("Content-Type", "application/json")
+		writer.Write([]byte(respJson))
+	}
+}
+
+func (service *MercuryFsService) checkAuthHeader(w http.ResponseWriter, r *http.Request) (user *HdaUser) {
+	authToken := r.Header.Get("Authorization")
+	user = service.Users.find(authToken)
+	if user == nil {
+		http.Error(w, "Authentication Failed", http.StatusUnauthorized)
+	}
+	return
+}
+
+func (service *MercuryFsService) authMiddleware(pass http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		service.checkAuthHeader(w, r)
+		pass(w, r)
+	}
+}
+
+func (service *MercuryFsService) shareReadAccess(pass http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user := service.checkAuthHeader(w, r)
+		shareName := r.URL.Query().Get("s")
+		if access, err := user.HasReadAccess(shareName); !access {
+			if err == nil {
+				http.Error(w, "Access Forbidden", http.StatusForbidden)
+			} else {
+				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			}
+			return
+		}
+		pass(w, r)
+	}
+}
+
+func (service *MercuryFsService) shareWriteAccess(pass http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user := service.checkAuthHeader(w, r)
+		shareName := r.URL.Query().Get("s")
+		if access, err := user.HasWriteAccess(shareName); !access {
+			if err == nil {
+				http.Error(w, "Access Forbidden", http.StatusForbidden)
+			} else {
+				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			}
+			return
+		}
+		pass(w, r)
+	}
+}

src/fs/debug_info.go

@@ -17,25 +17,25 @@ import (
 type debugInfo struct {
 	last time.Time
 
-	num_requests_received, num_requests_served, num_bytes_served int64
+	numRequestsReceived, numRequestsServed, numBytesServed int64
 
 	sync.RWMutex
 }
 
-func (this *debugInfo) everything() (last_served_time time.Time, num_received, num_served, bytes_served int64) {
-	this.RLock()
-	last_served_time = this.last
-	num_received = this.num_requests_received
-	num_served = this.num_requests_served
-	bytes_served = this.num_bytes_served
-	this.RUnlock()
+func (d *debugInfo) everything() (lastServedTime time.Time, numReceived, numServed, bytesServed int64) {
+	d.RLock()
+	lastServedTime = d.last
+	numReceived = d.numRequestsReceived
+	numServed = d.numRequestsServed
+	bytesServed = d.numBytesServed
+	d.RUnlock()
 	return
 }
 
-func (this *debugInfo) requestServed(bytes_served int64) {
-	this.Lock()
-	this.num_requests_served++
-	this.num_bytes_served += bytes_served
-	this.last = time.Now()
-	this.Unlock()
+func (d *debugInfo) requestServed(bytesServed int64) {
+	d.Lock()
+	d.numRequestsServed++
+	d.numBytesServed += bytesServed
+	d.last = time.Now()
+	d.Unlock()
 }

src/fs/file_info.go

@@ -21,10 +21,10 @@ import (
 )
 
 type fileInfo struct {
-	name      string
-	mime_type string
-	mtime     time.Time
-	size      int64
+	name     string
+	mimeType string
+	mtime    time.Time
+	size     int64
 }
 
 type fileSorter struct {
@@ -46,53 +46,54 @@ func (fi *fileSorter) Less(i, j int) bool {
 	return strings.ToLower(fi.files[i].name) < strings.ToLower(fi.files[j].name)
 }
 
-func (this *fileInfo) to_json() string {
-	name, _ := json.Marshal(this.name)
-	return fmt.Sprintf(`{"name": %s, "mime_type": "%s", "mtime": "%s", "size": %d}`, string(name), this.mime_type, this.mtime.Format(http.TimeFormat), this.size)
+func (f *fileInfo) toJson() string {
+	name, _ := json.Marshal(f.name)
+	return fmt.Sprintf(`{"name": %s, "mime_type": "%s", "mtime": "%s", "size": %d}`,
+		string(name), f.mimeType, f.mtime.Format(http.TimeFormat), f.size)
 }
 
-func directory_fileInfos(fis []os.FileInfo, full_path string) []fileInfo {
-	file_infos := []fileInfo{}
+func directoryFileInfos(fis []os.FileInfo, fullPath string) []fileInfo {
+	fileInfos := make([]fileInfo, 0)
 	for i := range fis {
 		if fis[i].Name()[0] == '.' {
 			continue
 		}
-		fileInfo := fileInfo {
+		fileInfo := fileInfo{
 			name:  fis[i].Name(),
 			mtime: fis[i].ModTime(),
 		}
-		if fis[i].IsDir() || isSymlinkDir(fis[i], full_path) {
-			fileInfo.mime_type = "text/directory"
+		if fis[i].IsDir() || isSymlinkDir(fis[i], fullPath) {
+			fileInfo.mimeType = "text/directory"
 			fileInfo.size = 0
 		} else {
-			fileInfo.mime_type = getContentType(fis[i].Name())
+			fileInfo.mimeType = getContentType(fis[i].Name())
 			fileInfo.size = fis[i].Size()
 		}
-		file_infos = append(file_infos, fileInfo)
+		fileInfos = append(fileInfos, fileInfo)
 	}
 
-	sorter := &fileSorter{files: file_infos}
+	sorter := &fileSorter{files: fileInfos}
 
 	sort.Sort(sorter)
 
-	return file_infos
+	return fileInfos
 }
 
-func dirToJSON(osFile *os.File, full_path string) (string, error) {
+func dirToJSON(osFile *os.File, fullPath string) (string, error) {
 	fis, err := osFile.Readdir(0)
 	if err != nil {
 		return "", err
 	}
 
-	file_infos := directory_fileInfos(fis, full_path)
+	fileInfos := directoryFileInfos(fis, fullPath)
 
-	if len(file_infos) == 0 {
+	if len(fileInfos) == 0 {
 		return "[]", nil
 	}
 
-	ss := []string{}
-	for i := range file_infos {
-		temp := file_infos[i].to_json()
+	ss := make([]string, 0)
+	for i := range fileInfos {
+		temp := fileInfos[i].toJson()
 		ss = append(ss, temp)
 	}
 
@@ -140,7 +141,7 @@ func getContentType(fileName string) string {
 		".wtv":  "video/x-ms-wtv",
 		".flv":  "video/x-flv",
 		".3gp":  "video/3gpp",
-		".webm":  "video/webm",
+		".webm": "video/webm",
 		".epub": "application/epub+zip",
 		".mobi": "application/x-mobipocket",
 		".zip":  "application/zip",
@@ -174,12 +175,12 @@ func getContentType(fileName string) string {
 		".htm":  "text/html",
 		".csv": "text/csv",
 		// subtitle stuff, with others below
-		".srt":  "application/x-subrip",
-		".sub":  "text/vnd.dvb.subtitle",
+		".srt": "application/x-subrip",
+		".sub": "text/vnd.dvb.subtitle",
 	}
 
-	sub_extensions := []string{".idx", ".sub", ".srt", ".ssa", ".ass", ".smi", ".utf", ".utf8", ".utf-8", ".rt", ".aqt", ".usf", ".jss", ".cdg", ".psb", ".mpsub", ".mpl2", ".pjs", ".dks", ".stl", ".vtt"}
-	for _, e := range sub_extensions {
+	subExtensions := []string{".idx", ".sub", ".srt", ".ssa", ".ass", ".smi", ".utf", ".utf8", ".utf-8", ".rt", ".aqt", ".usf", ".jss", ".cdg", ".psb", ".mpsub", ".mpl2", ".pjs", ".dks", ".stl", ".vtt"}
+	for _, e := range subExtensions {
 		encodingMap[e] = "application/x-subtitle"
 	}