"github.com/ethereum/go-ethereum/common"

"github.com/ethereum/go-ethereum/log"

"github.com/ethereum/go-ethereum/swarm/api"

"github.com/ethereum/go-ethereum/swarm/storage"

"github.com/rs/cors"

)

// ServerConfig is the basic configuration needed for the HTTP server and also

// includes CORS settings.

type ServerConfig struct {

// HandlePostRaw handles a POST request to a raw bzz-raw:/ URI, stores the request

// body in swarm and returns the resulting storage key as a text/plain response

func (s *Server) HandlePostRaw(w http.ResponseWriter, r *Request) {

if r.uri.Path != "" {

s.BadRequest(w, r, "raw POST request cannot contain a path")

return

}

if r.Header.Get("Content-Length") == "" {

s.BadRequest(w, r, "missing Content-Length header in request")

return

}

key, err := s.api.Store(r.Body, r.ContentLength, nil)

if err != nil {

s.Error(w, r, err)

return

}

// existing manifest or to a new manifest under <path> and returns the

// resulting manifest hash as a text/plain response

func (s *Server) HandlePostFiles(w http.ResponseWriter, r *Request) {

contentType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))

if err != nil {

s.BadRequest(w, r, err.Error())

return

}

if r.uri.Addr != "" {

key, err = s.api.Resolve(r.uri)

if err != nil {

s.Error(w, r, fmt.Errorf("error resolving %s: %s", r.uri.Addr, err))

return

}

} else {

key, err = s.api.NewManifest()

if err != nil {

s.Error(w, r, err)

return

}

}

})

if err != nil {

s.Error(w, r, fmt.Errorf("error creating manifest: %s", err))

return

}

// <path> from <manifest> and returns the resulting manifest hash as a

// text/plain response

func (s *Server) HandleDelete(w http.ResponseWriter, r *Request) {

key, err := s.api.Resolve(r.uri)

if err != nil {

s.Error(w, r, fmt.Errorf("error resolving %s: %s", r.uri.Addr, err))

return

}

return mw.RemoveEntry(r.uri.Path)

})

if err != nil {

s.Error(w, r, fmt.Errorf("error updating manifest: %s", err))

return

}

// - bzz-hash://<key> and responds with the hash of the content stored

// at the given storage key as a text/plain response

func (s *Server) HandleGet(w http.ResponseWriter, r *Request) {

key, err := s.api.Resolve(r.uri)

if err != nil {

return

}

if r.uri.Path != "" {

walker, err := s.api.NewManifestWalker(key, nil)

if err != nil {

s.BadRequest(w, r, fmt.Sprintf("%s is not a manifest", key))

return

}

return api.SkipManifest

})

if entry == nil {

s.NotFound(w, r, fmt.Errorf("Manifest entry could not be loaded"))

return

}

// check the root chunk exists by retrieving the file's size

reader := s.api.Retrieve(key)

if _, err := reader.Size(nil); err != nil {

s.NotFound(w, r, fmt.Errorf("Root chunk not found %s: %s", key, err))

return

}

switch {

// allow the request to overwrite the content type using a query

// parameter

contentType := "application/octet-stream"

// header of "application/x-tar" and returns a tar stream of all files

// contained in the manifest

func (s *Server) HandleGetFiles(w http.ResponseWriter, r *Request) {

if r.uri.Path != "" {

s.BadRequest(w, r, "files request cannot contain a path")

return

}

key, err := s.api.Resolve(r.uri)

if err != nil {

return

}

walker, err := s.api.NewManifestWalker(key, nil)

if err != nil {

s.Error(w, r, err)

return

}

return nil

})

if err != nil {

s.logError("error generating tar stream: %s", err)

}

}

// a list of all files contained in <manifest> under <path> grouped into

// common prefixes using "/" as a delimiter

func (s *Server) HandleGetList(w http.ResponseWriter, r *Request) {

// ensure the root path has a trailing slash so that relative URLs work

if r.uri.Path == "" && !strings.HasSuffix(r.URL.Path, "/") {

http.Redirect(w, &r.Request, r.URL.Path+"/", http.StatusMovedPermanently)

key, err := s.api.Resolve(r.uri)

if err != nil {

return

}

list, err := s.getManifestList(key, r.uri.Path)

if err != nil {

s.Error(w, r, err)

return

}

List: &list,

})

if err != nil {

s.logError("error rendering list HTML: %s", err)

}

return

// HandleGetFile handles a GET request to bzz://<manifest>/<path> and responds

// with the content of the file at <path> from the given <manifest>

func (s *Server) HandleGetFile(w http.ResponseWriter, r *Request) {

// ensure the root path has a trailing slash so that relative URLs work

if r.uri.Path == "" && !strings.HasSuffix(r.URL.Path, "/") {

http.Redirect(w, &r.Request, r.URL.Path+"/", http.StatusMovedPermanently)

key, err := s.api.Resolve(r.uri)

if err != nil {

return

}

if err != nil {

switch status {

case http.StatusNotFound:

s.NotFound(w, r, err)

default:

s.Error(w, r, err)

}

return

list, err := s.getManifestList(key, r.uri.Path)

if err != nil {

s.Error(w, r, err)

return

}

s.logDebug(fmt.Sprintf("Multiple choices! --> %v", list))

//show a nice page links to available entries

return

}

// check the root chunk exists by retrieving the file's size

if _, err := reader.Size(nil); err != nil {

s.NotFound(w, r, fmt.Errorf("File not found %s: %s", r.uri, err))

return

}

}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {

s.logDebug("HTTP %s request URL: '%s', Host: '%s', Path: '%s', Referer: '%s', Accept: '%s'", r.Method, r.RequestURI, r.URL.Host, r.URL.Path, r.Referer(), r.Header.Get("Accept"))

uri, err := api.Parse(strings.TrimLeft(r.URL.Path, "/"))

req := &Request{Request: *r, uri: uri}

if err != nil {

// strictly a traditional PUT request which replaces content

// at a URI, and POST is more ubiquitous)

if uri.Raw() || uri.DeprecatedRaw() {

return

} else {

s.HandlePostFiles(w, req)

case "DELETE":

if uri.Raw() || uri.DeprecatedRaw() {

return

}

s.HandleDelete(w, req)

s.HandleGetFile(w, req)

default:

}

}

}

func (s *Server) BadRequest(w http.ResponseWriter, r *Request, reason string) {

}

func (s *Server) Error(w http.ResponseWriter, r *Request, err error) {

}

func (s *Server) NotFound(w http.ResponseWriter, r *Request, err error) {

}