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 )
  24
  25 var dir, file = path.Split(path.Clean(os.Getenv("_")))
  26 var kFrontEndFiles string = path.Join(dir, "fe")
  27 var gConfig *config.Configuration = nil
  28
  29 func indexHandler(response http.ResponseWriter, request *http.Request) {
  30   var fileName string = "index.html"
  31   if strings.HasPrefix(request.URL.Path, "/_@/") {
  32     fileName = "service_request.html"
  33   }
  34   fd, err := os.Open(path.Join(kFrontEndFiles, fileName), os.O_RDONLY, 0)
  35   if err != nil {
  36     fmt.Print("Error opening file ", err.String(), "\n")
  37     return
  38   }
  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.String())
  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.String())
  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.String())
  72       } else {
  73         data := map[string] string {
  74           "path" : target,
  75         }
  76         okResponse(response, data)
  77       }
  78     default:
  79       errorResponse(response, "Unhandled action")
  80   }
  81 }
  82
  83 func proxyHandler(response http.ResponseWriter, request *http.Request) {
  84   rawURL := request.FormValue("url")
  85   if len(rawURL) < 1 {
  86     return
  87   }
  88
  89   var validURL bool = false
  90   for i := range gConfig.ProxyURLs {
  91     allowedURL := gConfig.ProxyURLs[i]
  92     validURL = validURL || strings.HasPrefix(rawURL, allowedURL)
  93   }
  94
  95   if !validURL {
  96     errorResponse(response, "URL is not in proxy whitelist")
  97     return
  98   }
  99
 100   url, err := http.ParseURL(rawURL)
 101   if err != nil {
 102     errorResponse(response, err.String())
 103     return
 104   }
 105   err = performProxy(url, response, request)
 106   if err != nil {
 107     errorResponse(response, err.String())
 108   }
 109 }
 110
 111 func performProxy(url *http.URL, response http.ResponseWriter, origRequest *http.Request) os.Error {
 112   conn, err := net.Dial("tcp", "", url.Host + ":http")
 113   if err != nil {
 114     return err
 115   }
 116   client := http.NewClientConn(conn, nil)
 117   var request http.Request
 118   request.URL = url
 119   request.Method = "GET"
 120   request.UserAgent = origRequest.UserAgent
 121   err = client.Write(&request)
 122   if err != nil {
 123     return err
 124   }
 125   var proxyResponse *http.Response
 126   proxyResponse, err = client.Read()
 127   if err != nil && err != http.ErrPersistEOF {
 128     return err
 129   }
 130   _, err = io.Copy(response, proxyResponse.Body)
 131   return err
 132 }
 133
 134 func errorResponse(response http.ResponseWriter, message string) {
 135   message = strings.Replace(message, gConfig.JailRoot, "/", -1)
 136   data := map[string] string {
 137     "error"   : "-1",
 138     "message" : message,
 139   }
 140   json_data, err := json.Marshal(data)
 141
 142   response.SetHeader("Content-Type", "text/json")
 143   if err != nil {
 144     io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
 145   } else {
 146     response.Write(json_data)
 147   }
 148 }
 149
 150 func okResponse(response http.ResponseWriter, data interface{}) {
 151   response.SetHeader("Content-Type", "text/json")
 152   json_data, err := json.Marshal(data)
 153   if err != nil {
 154     errorResponse(response, "Internal encoding error")
 155   } else {
 156     response.Write(json_data)
 157   }
 158 }
 159
 160 func RunBackEnd(config *config.Configuration) {
 161   mux := http.NewServeMux()
 162   mux.HandleFunc("/", indexHandler)
 163   mux.Handle("/fe/", http.FileServer(kFrontEndFiles, "/fe/"))
 164   mux.HandleFunc("/service", serviceHandler)
 165   mux.HandleFunc("/proxy", proxyHandler)
 166
 167   gConfig = config
 168
 169   error := http.ListenAndServe(fmt.Sprintf(":%d", config.Port), mux)
 170   fmt.Printf("error %v", error)
 171 }