server/server.go

   1 //
   2 // Armadillo File Manager
   3 // Copyright (c) 2010-2011, Robert Sesek <http://www.bluestatic.org>
   4 //
   5 // This program is free software: you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free Software
   7 // Foundation, either version 3 of the License, or any later version.
   8 //
   9
  10 package server
  11
  12 import (
  13         "../config"
  14         "encoding/json"
  15         "fmt"
  16         "io"
  17         "net"
  18         "net/http"
  19         "net/http/httputil"
  20         "net/url"
  21         "os"
  22         "path"
  23         "strings"
  24 )
  25
  26 var dir, file = path.Split(path.Clean(os.Getenv("_")))
  27 var kFrontEndFiles string = path.Join(dir, "fe")
  28 var gConfig *config.Configuration
  29
  30 func SetConfig(aConfig *config.Configuration) {
  31         gConfig = aConfig
  32 }
  33
  34 func indexHandler(response http.ResponseWriter, request *http.Request) {
  35         fd, err := os.Open(path.Join(kFrontEndFiles, "index.html"))
  36         if err != nil {
  37                 fmt.Print("Error opening file ", err.Error(), "\n")
  38                 return
  39         }
  40         defer fd.Close()
  41
  42         response.Header().Set("Content-Type", "text/html")
  43         io.Copy(response, fd)
  44 }
  45
  46 func serviceHandler(response http.ResponseWriter, request *http.Request) {
  47         if request.Method != "POST" {
  48                 io.WriteString(response, "Error: Not a POST request")
  49                 return
  50         }
  51
  52         switch request.FormValue("action") {
  53         case "list":
  54                 files, err := ListPath(request.FormValue("path"))
  55                 if err != nil {
  56                         errorResponse(response, err.Error())
  57                 } else {
  58                         okResponse(response, files)
  59                 }
  60         case "remove":
  61                 err := RemovePath(request.FormValue("path"))
  62                 if err != nil {
  63                         errorResponse(response, err.Error())
  64                 } else {
  65                         data := map[string]int{
  66                                 "error": 0,
  67                         }
  68                         okResponse(response, data)
  69                 }
  70         case "move":
  71                 source := request.FormValue("source")
  72                 target := request.FormValue("target")
  73                 err := MovePath(source, target)
  74                 if err != nil {
  75                         errorResponse(response, err.Error())
  76                 } else {
  77                         data := map[string]interface{}{
  78                                 "path":  target,
  79                                 "error": 0,
  80                         }
  81                         okResponse(response, data)
  82                 }
  83         case "mkdir":
  84                 path := request.FormValue("path")
  85                 err := MakeDir(path)
  86                 if err != nil {
  87                         errorResponse(response, err.Error())
  88                 } else {
  89                         data := map[string]interface{}{
  90                                 "path":  path,
  91                                 "error": 0,
  92                         }
  93                         okResponse(response, data)
  94                 }
  95         case "tv_rename":
  96                 newPath, err := RenameTVEpisode(request.FormValue("path"))
  97                 if err != nil {
  98                         errorResponse(response, err.Error())
  99                 } else {
 100                         data := map[string]interface{}{
 101                                 "path":  *newPath,
 102                                 "error": 0,
 103                         }
 104                         okResponse(response, data)
 105                 }
 106         default:
 107                 fmt.Printf("Invalid action: '%s'\n", request.FormValue("action"))
 108                 errorResponse(response, "Unhandled action")
 109         }
 110 }
 111
 112 func proxyHandler(response http.ResponseWriter, request *http.Request) {
 113         rawURL := request.FormValue("url")
 114         if len(rawURL) < 1 {
 115                 return
 116         }
 117
 118         var validURL bool = false
 119         for i := range gConfig.ProxyURLs {
 120                 allowedURL := gConfig.ProxyURLs[i]
 121                 validURL = validURL || strings.HasPrefix(rawURL, allowedURL)
 122         }
 123
 124         if !validURL {
 125                 errorResponse(response, "URL is not in proxy whitelist")
 126                 return
 127         }
 128
 129         url_, err := url.Parse(rawURL)
 130         if err != nil {
 131                 errorResponse(response, err.Error())
 132                 return
 133         }
 134         err = performProxy(url_, response, request)
 135         if err != nil {
 136                 errorResponse(response, err.Error())
 137         }
 138 }
 139
 140 func performProxy(url_ *url.URL, response http.ResponseWriter, origRequest *http.Request) error {
 141         conn, err := net.Dial("tcp", url_.Host+":http")
 142         if err != nil {
 143                 return err
 144         }
 145         client := httputil.NewClientConn(conn, nil)
 146         request, err := http.NewRequest("GET", url_.String(), nil)
 147         if err != nil {
 148                 return err
 149         }
 150         request.Header.Set("User-Agent", origRequest.UserAgent())
 151         err = client.Write(request)
 152         if err != nil {
 153                 return err
 154         }
 155         var proxyResponse *http.Response
 156         proxyResponse, err = client.Read(request)
 157         if err != nil && err != httputil.ErrPersistEOF {
 158                 return err
 159         }
 160         _, err = io.Copy(response, proxyResponse.Body)
 161         return err
 162 }
 163
 164 func downloadHandler(response http.ResponseWriter, request *http.Request) {
 165         valid, fullPath := IsValidPath(request.FormValue("path"))
 166         if valid {
 167                 info, _ := os.Lstat(fullPath) // Error is already checked by |valid|.
 168                 if info.IsDir() {
 169                         http.Error(response, "Path is a directory", http.StatusBadRequest)
 170                 } else {
 171                         http.ServeFile(response, request, fullPath)
 172                 }
 173         } else {
 174                 http.NotFound(response, request)
 175         }
 176 }
 177
 178 func errorResponse(response http.ResponseWriter, message string) {
 179         message = strings.Replace(message, gConfig.JailRoot, "/", -1)
 180         data := map[string]interface{}{
 181                 "error":   -1,
 182                 "message": message,
 183         }
 184         json_data, err := json.Marshal(data)
 185
 186         response.Header().Set("Content-Type", "text/json")
 187         if err != nil {
 188                 io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
 189         } else {
 190                 response.Write(json_data)
 191         }
 192 }
 193
 194 func okResponse(response http.ResponseWriter, data interface{}) {
 195         response.Header().Set("Content-Type", "text/json")
 196         json_data, err := json.Marshal(data)
 197         if err != nil {
 198                 errorResponse(response, "Internal encoding error")
 199         } else {
 200                 response.Write(json_data)
 201         }
 202 }
 203
 204 func RunBackEnd() {
 205         mux := http.NewServeMux()
 206         mux.HandleFunc("/", indexHandler)
 207         mux.Handle("/fe/", http.StripPrefix("/fe/", http.FileServer(http.Dir(kFrontEndFiles))))
 208         mux.HandleFunc("/service", serviceHandler)
 209         mux.HandleFunc("/download", downloadHandler)
 210         mux.HandleFunc("/proxy", proxyHandler)
 211
 212         error := http.ListenAndServe(fmt.Sprintf(":%d", gConfig.Port), mux)
 213         fmt.Printf("error %v", error)
 214 }