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