forked from projectdiscovery/simplehttpserver
/
simplehttpserver.go
109 lines (93 loc) · 2.88 KB
/
simplehttpserver.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package main
import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/http/httputil"
"path"
)
type options struct {
ListenAddress string
Folder string
Certificate string
Key string
HTTPS bool
Verbose bool
Upload bool
}
var opts options
func main() {
flag.StringVar(&opts.ListenAddress, "listen", "0.0.0.0:8000", "Address:Port")
flag.StringVar(&opts.Folder, "path", ".", "Folder")
flag.BoolVar(&opts.Upload, "upload", false, "Enable upload via PUT")
flag.BoolVar(&opts.HTTPS, "https", false, "HTTPS")
flag.StringVar(&opts.Certificate, "cert", "", "Certificate")
flag.StringVar(&opts.Key, "key", "", "Key")
flag.BoolVar(&opts.Verbose, "v", false, "Verbose")
flag.Parse()
if flag.NArg() > 0 && opts.Folder == "." {
opts.Folder = flag.Args()[0]
}
log.Printf("Serving %s on http://%s/...", opts.Folder, opts.ListenAddress)
if opts.Upload {
log.Println("Upload enabled")
}
if opts.HTTPS {
if opts.Certificate == "" || opts.Key == "" {
log.Fatal("Certificate or Key file not specified")
}
fmt.Println(http.ListenAndServeTLS(opts.ListenAddress, opts.Certificate, opts.Key, loglayer(http.FileServer(http.Dir(opts.Folder)))))
} else {
fmt.Println(http.ListenAndServe(opts.ListenAddress, loglayer(http.FileServer(http.Dir(opts.Folder)))))
}
}
func loglayer(handler http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fullRequest, _ := httputil.DumpRequest(r, true)
lrw := newLoggingResponseWriter(w)
handler.ServeHTTP(lrw, r)
// Handles file write if enabled
if opts.Upload && r.Method == http.MethodPut {
data, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err)
}
err = handleUpload(path.Base(r.URL.Path), data)
if err != nil {
log.Println(err)
}
}
if opts.Verbose {
headers := new(bytes.Buffer)
lrw.Header().Write(headers) //nolint
log.Printf("\nRemote Address: %s\n%s\n%s %d %s\n%s\n%s\n", r.RemoteAddr, string(fullRequest), r.Proto, lrw.statusCode, http.StatusText(lrw.statusCode), headers.String(), string(lrw.Data))
} else {
log.Printf("%s \"%s %s %s\" %d %d", r.RemoteAddr, r.Method, r.URL, r.Proto, lrw.statusCode, len(lrw.Data))
}
})
}
type loggingResponseWriter struct {
http.ResponseWriter
statusCode int
Data []byte
}
func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
return &loggingResponseWriter{w, http.StatusOK, []byte{}}
}
func (lrw *loggingResponseWriter) Write(data []byte) (int, error) {
lrw.Data = append(lrw.Data, data...)
return lrw.ResponseWriter.Write(data)
}
func (lrw *loggingResponseWriter) Header() http.Header {
return lrw.ResponseWriter.Header()
}
func (lrw *loggingResponseWriter) WriteHeader(code int) {
lrw.statusCode = code
lrw.ResponseWriter.WriteHeader(code)
}
func handleUpload(file string, data []byte) error {
return ioutil.WriteFile(file, data, 0655)
}