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