src/server.go

   1 //
   2 // Armadillo File Manager
   3 // Copyright (c) 2010, 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 "tv_rename":
  77                 newPath, err := tv_rename.RenameEpisode(request.FormValue("path"))
  78                 if err != nil {
  79                         errorResponse(response, err.String())
  80                 } else {
  81                         data := map[string]interface{}{
  82                                 "path":  *newPath,
  83                                 "error": 0,
  84                         }
  85                         okResponse(response, data)
  86                 }
  87         case "download":
  88                 valid, fullPath := paths.IsValid(request.FormValue("path"))
  89                 if valid {
  90                         info, _ := os.Lstat(fullPath)  // Error is already checked by |valid|.
  91                         if info.IsDirectory() {
  92                                 errorResponse(response, "File is a directory")
  93                                 return
  94                         }
  95                         http.ServeFile(response, request, fullPath)
  96                 } else {
  97                         errorResponse(response, "Invalid path")
  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 errorResponse(response http.ResponseWriter, message string) {
 157         message = strings.Replace(message, gConfig.JailRoot, "/", -1)
 158         data := map[string]interface{}{
 159                 "error":   -1,
 160                 "message": message,
 161         }
 162         json_data, err := json.Marshal(data)
 163
 164         response.Header().Set("Content-Type", "text/json")
 165         if err != nil {
 166                 io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
 167         } else {
 168                 response.Write(json_data)
 169         }
 170 }
 171
 172 func okResponse(response http.ResponseWriter, data interface{}) {
 173         response.Header().Set("Content-Type", "text/json")
 174         json_data, err := json.Marshal(data)
 175         if err != nil {
 176                 errorResponse(response, "Internal encoding error")
 177         } else {
 178                 response.Write(json_data)
 179         }
 180 }
 181
 182 func RunBackEnd(config *config.Configuration) {
 183         mux := http.NewServeMux()
 184         mux.HandleFunc("/", indexHandler)
 185         mux.Handle("/fe/", http.FileServer(kFrontEndFiles, "/fe/"))
 186         mux.HandleFunc("/service", serviceHandler)
 187         mux.HandleFunc("/proxy", proxyHandler)
 188
 189         gConfig = config
 190
 191         error := http.ListenAndServe(fmt.Sprintf(":%d", config.Port), mux)
 192         fmt.Printf("error %v", error)
 193 }