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"), os.O_RDONLY, 0)
  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     default:
  88       fmt.Printf("Invalid action: '%s'\n", request.FormValue("action"))
  89       errorResponse(response, "Unhandled action")
  90   }
  91 }
  92
  93 func proxyHandler(response http.ResponseWriter, request *http.Request) {
  94   rawURL := request.FormValue("url")
  95   if len(rawURL) < 1 {
  96     return
  97   }
  98
  99   var validURL bool = false
 100   for i := range gConfig.ProxyURLs {
 101     allowedURL := gConfig.ProxyURLs[i]
 102     validURL = validURL || strings.HasPrefix(rawURL, allowedURL)
 103   }
 104
 105   if !validURL {
 106     errorResponse(response, "URL is not in proxy whitelist")
 107     return
 108   }
 109
 110   url, err := http.ParseURL(rawURL)
 111   if err != nil {
 112     errorResponse(response, err.String())
 113     return
 114   }
 115   err = performProxy(url, response, request)
 116   if err != nil {
 117     errorResponse(response, err.String())
 118   }
 119 }
 120
 121 func performProxy(url *http.URL, response http.ResponseWriter, origRequest *http.Request) os.Error {
 122   conn, err := net.Dial("tcp", "", url.Host + ":http")
 123   if err != nil {
 124     return err
 125   }
 126   client := http.NewClientConn(conn, nil)
 127   var request http.Request
 128   request.URL = url
 129   request.Method = "GET"
 130   request.UserAgent = origRequest.UserAgent
 131   err = client.Write(&request)
 132   if err != nil {
 133     return err
 134   }
 135   var proxyResponse *http.Response
 136   proxyResponse, err = client.Read()
 137   if err != nil && err != http.ErrPersistEOF {
 138     return err
 139   }
 140   _, err = io.Copy(response, proxyResponse.Body)
 141   return err
 142 }
 143
 144 func errorResponse(response http.ResponseWriter, message string) {
 145   message = strings.Replace(message, gConfig.JailRoot, "/", -1)
 146   data := map[string] interface{} {
 147     "error"   : -1,
 148     "message" : message,
 149   }
 150   json_data, err := json.Marshal(data)
 151
 152   response.SetHeader("Content-Type", "text/json")
 153   if err != nil {
 154     io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
 155   } else {
 156     response.Write(json_data)
 157   }
 158 }
 159
 160 func okResponse(response http.ResponseWriter, data interface{}) {
 161   response.SetHeader("Content-Type", "text/json")
 162   json_data, err := json.Marshal(data)
 163   if err != nil {
 164     errorResponse(response, "Internal encoding error")
 165   } else {
 166     response.Write(json_data)
 167   }
 168 }
 169
 170 func RunBackEnd(config *config.Configuration) {
 171   mux := http.NewServeMux()
 172   mux.HandleFunc("/", indexHandler)
 173   mux.Handle("/fe/", http.FileServer(kFrontEndFiles, "/fe/"))
 174   mux.HandleFunc("/service", serviceHandler)
 175   mux.HandleFunc("/proxy", proxyHandler)
 176
 177   gConfig = config
 178
 179   error := http.ListenAndServe(fmt.Sprintf(":%d", config.Port), mux)
 180   fmt.Printf("error %v", error)
 181 }