Big bang. Pretty much complete.

mark.george / httpcat

Browse code Big bang. Pretty much complete. master
1 parent bd7e651 commit 952a3a130a00e4c75d0b4d99dc4255fb337b9039 Mark George authored on 23 Feb 2022

Patch

Showing 11 changed files

Ignore Space Show notes View src/LICENSE 0 → 100644
Zero-Clause BSD License Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Ignore Space Show notes View

src/LICENSE 0 → 100644

Ignore Space Show notes View src/client.go
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License / package main import ( "fmt" "net/http" "os" "strings" ) type ClientCommand struct { URL string `short:"u" long:"uri" description:"The URI to send the request to" required:"true"` Headers []string `long:"header" description:"A header to add to request in the form name:value. Use multiple times for multiple headers."` Method string `short:"m" long:"method" description:"HTTP method for request" default:"GET"` Body string `short:"b" long:"body" description:"Request body to send"` } func (opts ClientCommand) Execute(args []string) error { sendRequest(opts) return nil } func sendRequest(opts ClientCommand) { client := http.Client{} request, _ := http.NewRequest(opts.Method, opts.URL, strings.NewReader(opts.Body)) // add extra headers if specified if len(opts.Headers) > 0 { for _, header := range opts.Headers { if name, value, err := parseHeader(header); err == nil { if globalOptions.Verbose { fmt.Println("Adding request header - " + name + ": " + value) } request.Header.Add(name, value) } else { fmt.Println("The following header is not in the correct format: " + header + "\nCorrect format is: 'name:value'") os.Exit(1) } } } if response, err := client.Do(request); err != nil { fmt.Println("Could not connect to server") } else { defer response.Body.Close() // show response if globalOptions.BodiesOnly { showResponseBody(response) } else if globalOptions.HeadersOnly { showResponseHeaders(response) } else { showEntireResponse(response) } } } package main import ( "fmt" ) type ClientCommand struct { URL string `short:"u" long:"uri" description:"The URI to send the reqest to." required:"true"` Accept string `short:"a" long:"accept" description:"Add 'Accept' header to request."` Method string `short:"m" long:"method" description:"HTTP method for request" default:"GET"` Body string `short:"b" long:"body" description:"Request body to send (for POST/PUT/PATCH)"` } func (c ClientCommand) Execute(args []string) error { fmt.Println("Send request to ", c.URL) return nil } // func sendRequest(uri string) { // client := http.Client{} // request, _ := http.NewRequest("GET", uri, nil) // // add Accept header if required by user // if accept != "" { // request.Header.Add("Accept", accept) // } // response, err := client.Do(request) // if err != nil { // fmt.Fprintln(os.Stderr, err) // } else { // // print entire response // if entire { // dump, _ := httputil.DumpResponse(response, true) // fmt.Println(string(dump[:])) // // print only the response body // } else { // body, _ := ioutil.ReadAll(response.Body) // fmt.Println(string(body[:])) // } // } // }

Ignore Space Show notes View

src/client.go

/**
  Author: Mark George <mark.george@otago.ac.nz>
  License: Zero-Clause BSD License
*/

package main

import (
	"fmt"
	"net/http"
	"os"
	"strings"
)

type ClientCommand struct {
	URL     string   `short:"u" long:"uri" description:"The URI to send the request to" required:"true"`
	Headers []string `long:"header" description:"A header to add to request in the form name:value. Use multiple times for multiple headers."`
	Method  string   `short:"m" long:"method" description:"HTTP method for request" default:"GET"`
	Body    string   `short:"b" long:"body" description:"Request body to send"`
}

func (opts *ClientCommand) Execute(args []string) error {
	sendRequest(opts)
	return nil
}

func sendRequest(opts *ClientCommand) {

client := http.Client{}

request, _ := http.NewRequest(opts.Method, opts.URL, strings.NewReader(opts.Body))

// add extra headers if specified
	if len(opts.Headers) > 0 {
		for _, header := range opts.Headers {
			if name, value, err := parseHeader(header); err == nil {

if globalOptions.Verbose {
					fmt.Println("Adding request header - " + name + ": " + value)
				}

request.Header.Add(name, value)
			} else {
				fmt.Println("The following header is not in the correct format: " + header + "\nCorrect format is: 'name:value'")
				os.Exit(1)
			}
		}
	}

if response, err := client.Do(request); err != nil {
		fmt.Println("Could not connect to server")
	} else {

defer response.Body.Close()

// show response
		if globalOptions.BodiesOnly {
			showResponseBody(response)
		} else if globalOptions.HeadersOnly {
			showResponseHeaders(response)
		} else {
			showEntireResponse(response)
		}
	}

}

package main

import (
	"fmt"
)

type ClientCommand struct {
	URL    string `short:"u" long:"uri" description:"The URI to send the reqest to." required:"true"`
	Accept string `short:"a" long:"accept" description:"Add 'Accept' header to request."`
	Method string `short:"m" long:"method" description:"HTTP method for request" default:"GET"`
	Body   string `short:"b" long:"body" description:"Request body to send (for POST/PUT/PATCH)"`
}

func (c *ClientCommand) Execute(args []string) error {
	fmt.Println("Send request to ", c.URL)
	return nil
}

// func sendRequest(uri string) {

// 	client := http.Client{}

// 	request, _ := http.NewRequest("GET", uri, nil)

// 	// add Accept header if required by user
// 	if accept != "" {
// 		request.Header.Add("Accept", accept)
// 	}

// 	response, err := client.Do(request)

// 	if err != nil {
// 		fmt.Fprintln(os.Stderr, err)
// 	} else {

// 		// print entire response
// 		if entire {
// 			dump, _ := httputil.DumpResponse(response, true)
// 			fmt.Println(string(dump[:]))

// 			// print only the response body
// 		} else {
// 			body, _ := ioutil.ReadAll(response.Body)
// 			fmt.Println(string(body[:]))
// 		}
// 	}
// }

Ignore Space Show notes View src/display.go 0 → 100644
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License / package main import ( "fmt" "io/ioutil" "net/http" "net/http/httputil" "time" "github.com/fatih/color" ) func showRequestBody(req http.Request) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgBlue) } body, _ := ioutil.ReadAll(req.Body) fmt.Println(string(body[:])) } func showResponseBody(rsp http.Response) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgRed) } body, _ := ioutil.ReadAll(rsp.Body) fmt.Println(string(body[:])) color.Unset() } func showRequestHeaders(req http.Request) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgBlue) } // show request line fmt.Println(req.Method + " " + req.URL.Path + " " + req.Proto) // show headers for k := range req.Header { fmt.Println(k + ": " + req.Header[k][0]) } color.Unset() } func showResponseHeaders(rsp http.Response) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgRed) } // show status line fmt.Println(rsp.Proto + " " + rsp.Status) // show headers for k := range rsp.Header { fmt.Println(k + ": " + rsp.Header[k][0]) } color.Unset() } func showEntireRequest(req http.Request) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgBlue) } dump, _ := httputil.DumpRequest(req, true) fmt.Println(string(dump[:])) color.Unset() } func showEntireResponse(rsp *http.Response) { showTimestamp() if !globalOptions.NoColour { color.Set(color.FgRed) } dumpRsp, _ := httputil.DumpResponse(rsp, true) fmt.Println(string(dumpRsp[:])) color.Unset() } func showTimestamp() { if !globalOptions.NoTimestamps { fmt.Println(time.Now().Format(time.StampMilli)) } }

Ignore Space Show notes View

src/display.go 0 → 100644

/**
  Author: Mark George <mark.george@otago.ac.nz>
  License: Zero-Clause BSD License
*/

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httputil"
	"time"

"github.com/fatih/color"
)

func showRequestBody(req *http.Request) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgBlue)
	}

body, _ := ioutil.ReadAll(req.Body)
	fmt.Println(string(body[:]))
}

func showResponseBody(rsp *http.Response) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgRed)
	}

body, _ := ioutil.ReadAll(rsp.Body)
	fmt.Println(string(body[:]))

color.Unset()
}

func showRequestHeaders(req *http.Request) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgBlue)
	}

// show request line
	fmt.Println(req.Method + " " + req.URL.Path + " " + req.Proto)

// show headers
	for k := range req.Header {
		fmt.Println(k + ": " + req.Header[k][0])
	}

color.Unset()
}

func showResponseHeaders(rsp *http.Response) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgRed)
	}

// show status line
	fmt.Println(rsp.Proto + " " + rsp.Status)

// show headers
	for k := range rsp.Header {
		fmt.Println(k + ": " + rsp.Header[k][0])
	}

color.Unset()
}

func showEntireRequest(req *http.Request) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgBlue)
	}

dump, _ := httputil.DumpRequest(req, true)
	fmt.Println(string(dump[:]))

color.Unset()
}

func showEntireResponse(rsp *http.Response) {
	showTimestamp()

if !globalOptions.NoColour {
		color.Set(color.FgRed)
	}

dumpRsp, _ := httputil.DumpResponse(rsp, true)
	fmt.Println(string(dumpRsp[:]))

color.Unset()
}

func showTimestamp() {
	if !globalOptions.NoTimestamps {
		fmt.Println(time.Now().Format(time.StampMilli))
	}
}

Ignore Space Show notes View src/global_options.go 0 → 100644
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License */ package main type GlobalOptions struct { Verbose bool `short:"v" long:"verbose" description:"Show additional details"` HeadersOnly bool `long:"headers" description:"Show headers and request/status line only (default is everything)"` BodiesOnly bool `long:"bodies" description:"Show bodies only (default is everything)"` NoColour bool `long:"nocolour" description:"Don't use colours (default is requests are blue and responses are red)"` NoTimestamps bool `long:"notimestamps" description:"Don't show timestamps"` } var ( globalOptions = new(GlobalOptions) )

Ignore Space Show notes View

src/global_options.go 0 → 100644

Ignore Space Show notes View src/go.mod
module httpcat go 1.17 require ( github.com/fatih/color v1.13.0 github.com/jessevdk/go-flags v1.5.0 ) require ( github.com/mattn/go-colorable v0.1.12 // indirect github.com/mattn/go-isatty v0.0.14 // indirect golang.org/x/sys v0.0.0-20220209214540-3681064d5158 // indirect ) module httpcat go 1.17 require ( github.com/fatih/color v1.13.0 github.com/jessevdk/go-flags v1.5.0 ) require ( github.com/mattn/go-colorable v0.1.12 // indirect github.com/mattn/go-isatty v0.0.14 // indirect golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect )

Ignore Space Show notes View

src/go.mod

Ignore Space Show notes View src/go.sum
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc= github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220209214540-3681064d5158 h1:rm+CHSpPEEW2IsXUib1ThaHIjuBVZjxNgSKmBLFfD4c= golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc= github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U= github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0= golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

Ignore Space Show notes View

src/go.sum

github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc=
github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220209214540-3681064d5158 h1:rm+CHSpPEEW2IsXUib1ThaHIjuBVZjxNgSKmBLFfD4c=
golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc=
github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

Show notes View src/httpcat.go 100644 → 0
/** Author: Mark George <mark.george@otago.ac.nz> Warranty: None. Works for me. If it doesn't work for you then you already have the source code... License: WTFPL v2 <http://www.wtfpl.net/txt/copying/> / package main // import ( // "flag" // "fmt" // "io/ioutil" // "net/http" // "net/http/httputil" // "os" // "strconv" // ) // var ( // port int // status int // body string // entire bool // verbose bool // server bool // uri string // accept string // separator string // cors bool // ) // func requestHandler(resp http.ResponseWriter, req http.Request) { // if verbose { // fmt.Printf("Received a %s request to %s\n", req.Method, req.RequestURI) // } // // print entire request // if entire { // dump, _ := httputil.DumpRequest(req, true) // fmt.Println(string(dump[:])) // // print only request body // } else { // body, _ := ioutil.ReadAll(req.Body) // fmt.Println(string(body[:])) // } // // cors // if cors && req.Method == http.MethodOptions { // if verbose { // fmt.Println("CORS preflight") // } // if origin := req.Header.Get("Origin"); origin != "" { // resp.Header().Set("Access-Control-Allow-Origin", origin) // if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" { // resp.Header().Set("Access-Control-Allow-Headers", headers) // } // if method := req.Header.Get("Access-Control-Request-Method"); method != "" { // resp.Header().Set("Access-Control-Allow-Method", method) // } // resp.WriteHeader(200) // return // } else { // if verbose { // fmt.Println("Preflight did not contain 'Origin' header!") // } // } // } // // send response // if body != "" { // if status == 204 { // status = 200 // } // if we have a body then we don't want to return the default 204 status // resp.WriteHeader(status) // fmt.Fprintf(resp, body) // } else { // resp.WriteHeader(status) // } // if separator != "" { // fmt.Println(separator) // } // } // func startServer() { // http.HandleFunc("/", requestHandler) // if err := http.ListenAndServe(":"+strconv.Itoa(port), nil); err != nil { // fmt.Fprintf(os.Stderr, "Could not start server. Is port %d available?\n", port) // } // } // func parseCommandLine() { // flag.IntVar(&port, "port", 8080, "") // flag.IntVar(&port, "p", 8080, "") // flag.IntVar(&status, "response", 204, "") // flag.IntVar(&status, "r", 204, "") // flag.StringVar(&body, "body", "", "") // flag.StringVar(&body, "b", "", "") // flag.BoolVar(&entire, "entire", false, "") // flag.BoolVar(&entire, "e", false, "") // flag.StringVar(&separator, "separator", "", "") // flag.StringVar(&separator, "s", "", "") // flag.BoolVar(&verbose, "verbose", false, "") // flag.BoolVar(&verbose, "v", false, "") // flag.StringVar(&accept, "accept", "", "") // flag.StringVar(&accept, "a", "", "") // flag.BoolVar(&cors, "cors", false, "") // flag.BoolVar(&cors, "c", false, "") // serverMode := flag.Bool("server", false, "") // clientMode := flag.Bool("client", false, "") // flag.Usage = usage // flag.Parse() // if !(serverMode \|\| clientMode) \|\| (serverMode && clientMode) { // usage() // os.Exit(1) // } else { // server = serverMode // } // if clientMode { // uri = flag.Arg(0) // if uri == "" { // usage() // os.Exit(1) // } // } // } // var usage = func() { // fmt.Fprintf(os.Stderr, "Usage:\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Client mode\n") // fmt.Fprintf(os.Stderr, " httpcat -client [options] http://uri-to-send-request-to.com\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Currently only supports GET requests.\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Server mode\n") // fmt.Fprintf(os.Stderr, " httpcat -server [options]\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Options (either mode)\n") // fmt.Fprintf(os.Stderr, " -entire or -e : Display entire request/response instead of just the body.\n") // fmt.Fprintf(os.Stderr, " -verbose or -v : Be verbose.\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Options (client mode only)\n") // fmt.Fprintf(os.Stderr, " -accept or -a [accept string] : Adds 'Accept' header to request.\n") // fmt.Fprintf(os.Stderr, "\n") // fmt.Fprintf(os.Stderr, " Options (server mode only)\n") // fmt.Fprintf(os.Stderr, " -body or -b [body message] : Body to respond with. Response code will default to 200.\n") // fmt.Fprintf(os.Stderr, " -port or -p [port] : Port to listen on.\n") // fmt.Fprintf(os.Stderr, " -response or -r [response code] : Status code to respond with. Defaults to 204.\n") // fmt.Fprintf(os.Stderr, " -cors or -c : Enable Cross Origin Resource Sharing support.\n") // fmt.Fprintf(os.Stderr, " -separator or -s [separator string] : Use the provided separator to separate messages.\n") // } // func xmain() { // parseCommandLine() // if server { // // server mode // if verbose { // fmt.Printf("Listening on port %d.\n", port) // if entire { // fmt.Println("Displaying entire request details.\n") // } else { // fmt.Println("Displaying bodies only.\n") // } // } // startServer() // } else { // // client mode // if verbose { // fmt.Println("Sending GET request to " + uri) // } // sendRequest(uri) // } // }

Show notes View

src/httpcat.go 100644 → 0

/**
Author:  Mark George <mark.george@otago.ac.nz>
Warranty:  None.  Works for me.  If it doesn't work for you then you already have the source code...
License: WTFPL v2 <http://www.wtfpl.net/txt/copying/>
*/

package main

// import (
// 	"flag"
// 	"fmt"
// 	"io/ioutil"
// 	"net/http"
// 	"net/http/httputil"
// 	"os"
// 	"strconv"
// )

// var (
// 	port      int
// 	status    int
// 	body      string
// 	entire    bool
// 	verbose   bool
// 	server    bool
// 	uri       string
// 	accept    string
// 	separator string
// 	cors      bool
// )

// func requestHandler(resp http.ResponseWriter, req *http.Request) {

// 	if verbose {
// 		fmt.Printf("Received a %s request to %s\n", req.Method, req.RequestURI)
// 	}

// 	// print entire request
// 	if entire {
// 		dump, _ := httputil.DumpRequest(req, true)
// 		fmt.Println(string(dump[:]))

// 		// print only request body
// 	} else {
// 		body, _ := ioutil.ReadAll(req.Body)
// 		fmt.Println(string(body[:]))
// 	}

// 	// cors
// 	if cors && req.Method == http.MethodOptions {
// 		if verbose {
// 			fmt.Println("CORS preflight")
// 		}

// 		if origin := req.Header.Get("Origin"); origin != "" {

// 			resp.Header().Set("Access-Control-Allow-Origin", origin)

// 			if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" {
// 				resp.Header().Set("Access-Control-Allow-Headers", headers)
// 			}

// 			if method := req.Header.Get("Access-Control-Request-Method"); method != "" {
// 				resp.Header().Set("Access-Control-Allow-Method", method)
// 			}

// 			resp.WriteHeader(200)

// 			return

// 		} else {
// 			if verbose {
// 				fmt.Println("Preflight did not contain 'Origin' header!")
// 			}
// 		}
// 	}

// 	// send response
// 	if body != "" {
// 		if status == 204 {
// 			status = 200
// 		} // if we have a body then we don't want to return the default 204 status
// 		resp.WriteHeader(status)
// 		fmt.Fprintf(resp, body)
// 	} else {
// 		resp.WriteHeader(status)
// 	}

// 	if separator != "" {
// 		fmt.Println(separator)
// 	}
// }

// func startServer() {
// 	http.HandleFunc("/", requestHandler)

// 	if err := http.ListenAndServe(":"+strconv.Itoa(port), nil); err != nil {
// 		fmt.Fprintf(os.Stderr, "Could not start server.  Is port %d available?\n", port)
// 	}
// }

// func parseCommandLine() {
// 	flag.IntVar(&port, "port", 8080, "")
// 	flag.IntVar(&port, "p", 8080, "")

// 	flag.IntVar(&status, "response", 204, "")
// 	flag.IntVar(&status, "r", 204, "")

// 	flag.StringVar(&body, "body", "", "")
// 	flag.StringVar(&body, "b", "", "")

// 	flag.BoolVar(&entire, "entire", false, "")
// 	flag.BoolVar(&entire, "e", false, "")

// 	flag.StringVar(&separator, "separator", "", "")
// 	flag.StringVar(&separator, "s", "", "")

// 	flag.BoolVar(&verbose, "verbose", false, "")
// 	flag.BoolVar(&verbose, "v", false, "")

// 	flag.StringVar(&accept, "accept", "", "")
// 	flag.StringVar(&accept, "a", "", "")

// 	flag.BoolVar(&cors, "cors", false, "")
// 	flag.BoolVar(&cors, "c", false, "")

// 	serverMode := flag.Bool("server", false, "")
// 	clientMode := flag.Bool("client", false, "")

// 	flag.Usage = usage

// 	flag.Parse()

// 	if !(*serverMode || *clientMode) || (*serverMode && *clientMode) {
// 		usage()
// 		os.Exit(1)
// 	} else {
// 		server = *serverMode
// 	}

// 	if *clientMode {
// 		uri = flag.Arg(0)
// 		if uri == "" {
// 			usage()
// 			os.Exit(1)
// 		}
// 	}

// }

// var usage = func() {
// 	fmt.Fprintf(os.Stderr, "Usage:\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "  Client mode\n")
// 	fmt.Fprintf(os.Stderr, "    httpcat -client [options] http://uri-to-send-request-to.com\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "    Currently only supports GET requests.\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "  Server mode\n")
// 	fmt.Fprintf(os.Stderr, "    httpcat -server [options]\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "  Options (either mode)\n")
// 	fmt.Fprintf(os.Stderr, "    -entire or -e : Display entire request/response instead of just the body.\n")
// 	fmt.Fprintf(os.Stderr, "    -verbose or -v : Be verbose.\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "  Options (client mode only)\n")
// 	fmt.Fprintf(os.Stderr, "    -accept or -a [accept string] : Adds 'Accept' header to request.\n")
// 	fmt.Fprintf(os.Stderr, "\n")
// 	fmt.Fprintf(os.Stderr, "  Options (server mode only)\n")
// 	fmt.Fprintf(os.Stderr, "    -body or -b [body message] : Body to respond with.  Response code will default to 200.\n")
// 	fmt.Fprintf(os.Stderr, "    -port or -p [port] : Port to listen on.\n")
// 	fmt.Fprintf(os.Stderr, "    -response or -r [response code] : Status code to respond with.  Defaults to 204.\n")
// 	fmt.Fprintf(os.Stderr, "    -cors or -c : Enable Cross Origin Resource Sharing support.\n")
// 	fmt.Fprintf(os.Stderr, "    -separator or -s [separator string] : Use the provided separator to separate messages.\n")
// }

// func xmain() {

// 	parseCommandLine()

// 	if server {

// 		// server mode

// 		if verbose {
// 			fmt.Printf("Listening on port %d.\n", port)
// 			if entire {
// 				fmt.Println("Displaying entire request details.\n")
// 			} else {
// 				fmt.Println("Displaying bodies only.\n")
// 			}
// 		}

// 		startServer()

// 	} else {

// 		// client mode

// 		if verbose {
// 			fmt.Println("Sending GET request to " + uri)
// 		}
// 		sendRequest(uri)
// 	}
// }

Ignore Space Show notes View src/main.go
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License / package main import ( "fmt" "os" "github.com/jessevdk/go-flags" ) const version string = "2.0" type VersionCommand struct{} func (c VersionCommand) Execute(args []string) error { fmt.Println("httpcat v" + version) return nil } func main() { parser := flags.NewParser(globalOptions, flags.Default) parser.AddCommand("client", "Send an HTTP request", "", &ClientCommand{}) parser.AddCommand("server", "Start a mock HTTP server", "", &ServerCommand{}) parser.AddCommand("proxy", "Start a reverse HTTP logging proxy", "", &ProxyCommand{}) parser.AddCommand("version", "Display version", "", &VersionCommand{}) _, err := parser.Parse() if err != nil { parseErr := err.(flags.Error) if parseErr.Type.String() == flags.ErrCommandRequired.String() { os.Stderr.WriteString("\n") parser.WriteHelp(os.Stderr) } } } package main import ( "fmt" "os" "github.com/jessevdk/go-flags" ) const version string = "2.0" type GlobalOptions struct { Verbose bool `short:"v" long:"verbose" description:"Print more details"` HeadersOnly bool `long:"headers" description:"Show headers only (default is everything)"` BodiesOnly bool `long:"bodies" description:"Show bodies only (default is everything)"` NoColour bool `long:"nocolour" description:"Don't use colours in the output"` } type VersionCommand struct { } func (c VersionCommand) Execute(args []string) error { fmt.Println("httpcat v" + version) return nil } var ( globalOptions = new(GlobalOptions) ) func main() { parser := flags.NewParser(globalOptions, flags.Default) parser.AddCommand("server", "Start a mock HTTP server", "", &ServerCommand{}) parser.AddCommand("client", "Send an HTTP request", "", &ClientCommand{}) parser.AddCommand("proxy", "Start reverse HTTP logging proxy", "", &ProxyCommand{}) parser.AddCommand("version", "Display version", "", &VersionCommand{}) // _, err := parser.ParseArgs(args[:]) _, err := parser.Parse() // is this really how you do error handling in Go? if err != nil { parseErr := err.(*flags.Error) if parseErr.Type.String() == flags.ErrCommandRequired.String() { os.Stderr.WriteString("\n") parser.WriteHelp(os.Stderr) } } }

Ignore Space Show notes View

src/main.go

package main

import (
	"fmt"
	"os"

"github.com/jessevdk/go-flags"
)

const version string = "2.0"

type GlobalOptions struct {
	Verbose     bool `short:"v" long:"verbose" description:"Print more details"`
	HeadersOnly bool `long:"headers" description:"Show headers only (default is everything)"`
	BodiesOnly  bool `long:"bodies" description:"Show bodies only (default is everything)"`
	NoColour    bool `long:"nocolour" description:"Don't use colours in the output"`
}

type VersionCommand struct {
}

func (c *VersionCommand) Execute(args []string) error {
	fmt.Println("httpcat v" + version)
	return nil
}

var (
	globalOptions = new(GlobalOptions)
)

func main() {

parser := flags.NewParser(globalOptions, flags.Default)

parser.AddCommand("server", "Start a mock HTTP server", "", &ServerCommand{})
	parser.AddCommand("client", "Send an HTTP request", "", &ClientCommand{})
	parser.AddCommand("proxy", "Start reverse HTTP logging proxy", "", &ProxyCommand{})
	parser.AddCommand("version", "Display version", "", &VersionCommand{})

// _, err := parser.ParseArgs(args[:])
	_, err := parser.Parse()

// is this really how you do error handling in Go?
	if err != nil {
		parseErr := err.(*flags.Error)

if parseErr.Type.String() == flags.ErrCommandRequired.String() {
			os.Stderr.WriteString("\n")
			parser.WriteHelp(os.Stderr)
		}
	}
}

Ignore Space Show notes View src/parsing.go 0 → 100644
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License */ package main import ( "errors" "strconv" "strings" ) var ( headers map[string]string = make(map[string]string) bodies map[string]string = make(map[string]string) statuses map[string]int = make(map[string]int) ) func parseHeader(header string) (string, string, error) { parts := strings.Split(header, ":") if len(parts) != 2 { return "", "", errors.New("header is not in the correct format") } else { name := parts[0] value := parts[1] headers[name] = value return name, value, nil } } func parseRoute(route string) (string, string, int, error) { parts := strings.Split(route, "\|") if len(parts) != 3 { return "", "", 0, errors.New("route is not in the correct format") } else { path := parts[0] body := parts[1] status := parts[2] code, err := strconv.Atoi(status) if err != nil { return "", "", 0, errors.New("route is not in the correct format") } bodies[path] = body statuses[path] = code return path, body, code, nil } }

Ignore Space Show notes View

src/parsing.go 0 → 100644

/**
  Author: Mark George <mark.george@otago.ac.nz>
  License: Zero-Clause BSD License
*/

package main

import (
	"errors"
	"strconv"
	"strings"
)

var (
	headers  map[string]string = make(map[string]string)
	bodies   map[string]string = make(map[string]string)
	statuses map[string]int    = make(map[string]int)
)

func parseHeader(header string) (string, string, error) {

parts := strings.Split(header, ":")

if len(parts) != 2 {
		return "", "", errors.New("header is not in the correct format")
	} else {
		name := parts[0]
		value := parts[1]

headers[name] = value

return name, value, nil
	}

}

func parseRoute(route string) (string, string, int, error) {

parts := strings.Split(route, "|")

if len(parts) != 3 {
		return "", "", 0, errors.New("route is not in the correct format")
	} else {
		path := parts[0]
		body := parts[1]
		status := parts[2]
		code, err := strconv.Atoi(status)
		if err != nil {
			return "", "", 0, errors.New("route is not in the correct format")
		}

bodies[path] = body
		statuses[path] = code

return path, body, code, nil
	}

}

Ignore Space Show notes View src/proxy.go
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License / package main import ( "fmt" "net/http" "net/http/httputil" "net/url" "strconv" ) type ProxyCommand struct { Port int `short:"p" long:"port" description:"The port that the proxy listens on." required:"true"` Target string `short:"t" long:"target" descrtiption:"The target web server that the proxy forwards requests to." required:"true"` } func (opts ProxyCommand) Execute(args []string) error { fmt.Println("Proxying port " + strconv.Itoa(opts.Port) + " to " + opts.Target) proxy, err := CreateProxy(opts.Target) if err != nil { panic(err) } http.HandleFunc("/", RequestHandler(proxy)) if err := http.ListenAndServe(":"+strconv.Itoa(opts.Port), nil); err != nil { panic(err) } return nil } func CreateProxy(target string) (httputil.ReverseProxy, error) { url, err := url.Parse(target) // bad target URL if err != nil { return nil, err } proxy := httputil.NewSingleHostReverseProxy(url) OriginalDirector := proxy.Director proxy.Director = func(req http.Request) { FixHeaders(url, req) showEntireRequest(req) // send request to target OriginalDirector(req) } proxy.ModifyResponse = func(rsp http.Response) error { showEntireResponse(rsp) return nil } proxy.ErrorHandler = func(http.ResponseWriter, http.Request, error) { fmt.Println("Could not connect to target server") } return proxy, nil } func FixHeaders(url url.URL, req http.Request) { // TODO this may be necessary for proxying HTTPS (need to test) req.URL.Host = url.Host req.URL.Scheme = url.Scheme req.Host = url.Host } func RequestHandler(proxy httputil.ReverseProxy) func(http.ResponseWriter, http.Request) { return func(w http.ResponseWriter, r http.Request) { proxy.ServeHTTP(w, r) } } /* Author: Mark George <mark.george@otago.ac.nz License: WTFPL v2 <http://www.wtfpl.net/txt/copying/> Original Source: https://gist.github.com/yowu/f7dc34bd4736a65ff28d / package main import ( // "flag" "fmt" // "io" // "log" "net/http" "net/http/httputil" "net/url" // "strings" "time" "github.com/fatih/color" ) type ProxyCommand struct { port string `short:"p" long:"port" description:"The port that the proxy listens on."` target string `short:"t" long:"target" descrtiption:"The target web server that the proxy forwards requests to."` } func (c ProxyCommand) Execute(args []string) error { fmt.Println("Start proxy") return nil } func copyHeader(dst, src http.Header) { for k, vv := range src { for _, v := range vv { dst.Add(k, v) } } } func CreateProxy(target string) (httputil.ReverseProxy, error) { url, err := url.Parse(target) // bad target URL if err != nil { return nil, err } proxy := httputil.NewSingleHostReverseProxy(url) OriginalDirector := proxy.Director proxy.Director = func(req http.Request) { FixHeaders(url, req) LogRequest(req) // send request to target OriginalDirector(req) } proxy.ModifyResponse = func(rsp http.Response) error { LogResponse(rsp) return nil } proxy.ErrorHandler = func(http.ResponseWriter, http.Request, error) { fmt.Println("Could not connect to target server\n") } return proxy, nil } func FixHeaders(url url.URL, req http.Request) { // this may be necessary for proxying HTTPS (need to test) req.URL.Host = url.Host req.URL.Scheme = url.Scheme req.Host = url.Host } func RequestHandler(proxy httputil.ReverseProxy) func(http.ResponseWriter, http.Request) { return func(w http.ResponseWriter, r http.Request) { proxy.ServeHTTP(w, r) } } func LogRequest(req http.Request) error { color.Set(color.FgWhite) fmt.Println(time.Now().Format(time.StampMilli)) dumpReq, _ := httputil.DumpRequest(req, true) color.Set(color.FgBlue) fmt.Println(string(dumpReq[:])) color.Unset() return nil } func LogResponse(rsp *http.Response) { color.Set(color.FgWhite) fmt.Println(time.Now().Format(time.StampMilli)) dumpRsp, _ := httputil.DumpResponse(rsp, true) color.Set(color.FgRed) fmt.Println(string(dumpRsp[:])) color.Unset() } func ymain() { // flag.StringVar(&listen, "listen", "9090", "The port that the proxy listens on.") // flag.StringVar(&listen, "l", "9090", "The port that the proxy listens on.") // flag.StringVar(&target, "target", "8080", "The port that the proxy forwards requests to.") // flag.StringVar(&target, "t", "8080", "The port that the proxy forwards requests to.") // flag.Parse() // handler := &proxy{} // log.Println("Forwarding port", listen, "to port", target) // if err := http.ListenAndServe("localhost:"+listen, handler); err != nil { // log.Fatal("ListenAndServe:", err) // } target := "http://localhost:8080" listenPort := "9090" proxy, err := CreateProxy(target) if err != nil { panic(err) } http.HandleFunc("/", RequestHandler(proxy)) if err := http.ListenAndServe(":"+listenPort, nil); err != nil { panic(err) } }

Ignore Space Show notes View

src/proxy.go

/**
  Author: Mark George <mark.george@otago.ac.nz>
  License: Zero-Clause BSD License
*/

package main

import (
	"fmt"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strconv"
)

type ProxyCommand struct {
	Port   int    `short:"p" long:"port" description:"The port that the proxy listens on." required:"true"`
	Target string `short:"t" long:"target" descrtiption:"The target web server that the proxy forwards requests to." required:"true"`
}

func (opts *ProxyCommand) Execute(args []string) error {
	fmt.Println("Proxying port " + strconv.Itoa(opts.Port) + " to " + opts.Target)

proxy, err := CreateProxy(opts.Target)

if err != nil {
		panic(err)
	}

http.HandleFunc("/", RequestHandler(proxy))
	if err := http.ListenAndServe(":"+strconv.Itoa(opts.Port), nil); err != nil {
		panic(err)
	}

return nil
}

func CreateProxy(target string) (*httputil.ReverseProxy, error) {

url, err := url.Parse(target)

// bad target URL
	if err != nil {
		return nil, err
	}

proxy := httputil.NewSingleHostReverseProxy(url)

OriginalDirector := proxy.Director
	proxy.Director = func(req *http.Request) {
		FixHeaders(url, req)
		showEntireRequest(req)

// send request to target
		OriginalDirector(req)
	}

proxy.ModifyResponse = func(rsp *http.Response) error {
		showEntireResponse(rsp)
		return nil
	}

proxy.ErrorHandler = func(http.ResponseWriter, *http.Request, error) {
		fmt.Println("Could not connect to target server")
	}

return proxy, nil
}

func FixHeaders(url *url.URL, req *http.Request) {
	// TODO this may be necessary for proxying HTTPS (need to test)
	req.URL.Host = url.Host
	req.URL.Scheme = url.Scheme
	req.Host = url.Host
}

func RequestHandler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		proxy.ServeHTTP(w, r)
	}
}

/**
Author: Mark George <mark.george@otago.ac.nz
License: WTFPL v2 <http://www.wtfpl.net/txt/copying/>
Original Source: https://gist.github.com/yowu/f7dc34bd4736a65ff28d
*/

package main

import (
	// "flag"
	"fmt"
	// "io"
	// "log"
	"net/http"
	"net/http/httputil"
	"net/url"

// "strings"
	"time"

"github.com/fatih/color"
)

type ProxyCommand struct {
	port   string `short:"p" long:"port" description:"The port that the proxy listens on."`
	target string `short:"t" long:"target" descrtiption:"The target web server that the proxy forwards requests to."`
}

func (c *ProxyCommand) Execute(args []string) error {
	fmt.Println("Start proxy")
	return nil
}

func copyHeader(dst, src http.Header) {
	for k, vv := range src {
		for _, v := range vv {
			dst.Add(k, v)
		}
	}
}

func CreateProxy(target string) (*httputil.ReverseProxy, error) {

url, err := url.Parse(target)

// bad target URL
	if err != nil {
		return nil, err
	}

proxy := httputil.NewSingleHostReverseProxy(url)

OriginalDirector := proxy.Director
	proxy.Director = func(req *http.Request) {
		FixHeaders(url, req)
		LogRequest(req)

// send request to target
		OriginalDirector(req)
	}

proxy.ModifyResponse = func(rsp *http.Response) error {
		LogResponse(rsp)
		return nil
	}

proxy.ErrorHandler = func(http.ResponseWriter, *http.Request, error) {
		fmt.Println("Could not connect to target server\n")
	}

return proxy, nil
}

func FixHeaders(url *url.URL, req *http.Request) {
	// this may be necessary for proxying HTTPS (need to test)
	req.URL.Host = url.Host
	req.URL.Scheme = url.Scheme
	req.Host = url.Host
}

func RequestHandler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		proxy.ServeHTTP(w, r)
	}
}

func LogRequest(req *http.Request) error {
	color.Set(color.FgWhite)
	fmt.Println(time.Now().Format(time.StampMilli))

dumpReq, _ := httputil.DumpRequest(req, true)

color.Set(color.FgBlue)
	fmt.Println(string(dumpReq[:]))
	color.Unset()
	return nil
}

func LogResponse(rsp *http.Response) {
	color.Set(color.FgWhite)
	fmt.Println(time.Now().Format(time.StampMilli))
	dumpRsp, _ := httputil.DumpResponse(rsp, true)
	color.Set(color.FgRed)
	fmt.Println(string(dumpRsp[:]))
	color.Unset()
}

func ymain() {
	// flag.StringVar(&listen, "listen", "9090", "The port that the proxy listens on.")
	// flag.StringVar(&listen, "l", "9090", "The port that the proxy listens on.")
	// flag.StringVar(&target, "target", "8080", "The port that the proxy forwards requests to.")
	// flag.StringVar(&target, "t", "8080", "The port that the proxy forwards requests to.")

// flag.Parse()

// handler := &proxy{}

// log.Println("Forwarding port", listen, "to port", target)
	// if err := http.ListenAndServe("localhost:"+listen, handler); err != nil {
	// 	log.Fatal("ListenAndServe:", err)
	// }

target := "http://localhost:8080"
	listenPort := "9090"
	proxy, err := CreateProxy(target)

if err != nil {
		panic(err)
	}

http.HandleFunc("/", RequestHandler(proxy))
	if err := http.ListenAndServe(":"+listenPort, nil); err != nil {
		panic(err)
	}
}

Ignore Space Show notes View src/server.go
/** Author: Mark George <mark.george@otago.ac.nz> License: Zero-Clause BSD License / package main import ( "fmt" "net/http" "os" "strconv" ) type ServerCommand struct { Port int `short:"p" long:"port" description:"Port to listen on." default:"8080"` Routes []string `short:"r" long:"route" description:"Route which is made up of a path, a response body, and a response status, all separated by the pipe character. Repeat for additional routes." default:"/\|testing\|200"` Cors bool `short:"c" long:"cors" description:"Enable Cross Origin Resource Sharing (CORS)."` Headers []string `short:"H" long:"header" description:"A header to add to response in the form name:value. Repeat for additional headers."` } var ( serverOptions ServerCommand ) func (opts ServerCommand) Execute(args []string) error { serverOptions = opts // parse custom headers if provided if len(opts.Headers) > 0 { for _, header := range opts.Headers { if _, _, err := parseHeader(header); err != nil { fmt.Println("The following header is not in the correct format: " + header + "\nCorrect format is: 'name:value'") os.Exit(1) } } } fmt.Println("HTTP server listening on port " + strconv.Itoa(opts.Port) + "\n") if len(opts.Routes) > 0 { fmt.Println("Routes:") for _, route := range opts.Routes { if path, _, _, err := parseRoute(route); err == nil { fmt.Println(" " + path) http.HandleFunc(path, serverRequestHandler) } else { fmt.Println("The following route is not in the correct format: " + route + "\nCorrect format is: \"/path\|response body\|status code\"") os.Exit(1) } } } / http.HandleFunc("/", serverRequestHandler) / if err := http.ListenAndServe(":"+strconv.Itoa(opts.Port), nil); err != nil { fmt.Fprintf(os.Stderr, "Could not start server. Is port %d available?\n", opts.Port) os.Exit(1) } return nil } func serverRequestHandler(rsp http.ResponseWriter, req http.Request) { path := req.RequestURI body := bodies[path] code := statuses[path] if globalOptions.BodiesOnly { showRequestBody(req) } else if globalOptions.HeadersOnly { showRequestHeaders(req) } else { showEntireRequest(req) } // CORS if serverOptions.Cors && req.Method == http.MethodOptions { if globalOptions.Verbose { fmt.Println("CORS preflight") } if origin := req.Header.Get("Origin"); origin != "" { rsp.Header().Set("Access-Control-Allow-Origin", origin) if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" { rsp.Header().Set("Access-Control-Allow-Headers", headers) } if method := req.Header.Get("Access-Control-Request-Method"); method != "" { rsp.Header().Set("Access-Control-Allow-Method", method) } rsp.WriteHeader(200) return } else { fmt.Println("WARNING - CORS preflight did not contain 'Origin' header!") } } // add custom headers if provided if len(serverOptions.Headers) > 0 { for name, value := range headers { if globalOptions.Verbose { fmt.Println("Adding response header - " + name + ": " + value) } rsp.Header().Set(name, value) } } // add status line rsp.WriteHeader(code) // add body fmt.Fprintf(rsp, body) } package main import ( "fmt" "io/ioutil" "net/http" "net/http/httputil" "os" "strconv" "time" ) type ServerCommand struct { Body string `short:"b" long:"body" description:"Body message to respond with."` Port int `short:"p" long:"port" description:"Port to listen on." default:"8080"` Status int `short:"s" long:"status" description:"Status code to respond with." default:"204"` Cors bool `shot:"c" long:"cors" description:"Enable Cross Origin Resource Sharing (CORS)."` } var ( serverOptions ServerCommand ) func (c ServerCommand) Execute(args []string) error { fmt.Println("HTTP server listening on port " + strconv.Itoa(c.Port) + "\n") http.HandleFunc("/", serverRequestHandler) serverOptions = c if err := http.ListenAndServe(":"+strconv.Itoa(c.Port), nil); err != nil { fmt.Fprintf(os.Stderr, "Could not start server. Is port %d available?\n", c.Port) os.Exit(1) } return nil } func serverRequestHandler(rsp http.ResponseWriter, req *http.Request) { if globalOptions.Verbose { fmt.Printf("Received a %s request to %s\n", req.Method, req.RequestURI) } fmt.Println(time.Now().Format(time.StampMilli)) if globalOptions.BodiesOnly { body, _ := ioutil.ReadAll(req.Body) fmt.Println(string(body[:])) } else if globalOptions.HeadersOnly { fmt.Println(req.Method + " " + req.URL.Path + " " + req.Proto) for k := range req.Header { fmt.Println(k + ": " + req.Header[k][0]) } // TODO } else { // dump entire request dump, _ := httputil.DumpRequest(req, true) fmt.Println(string(dump[:])) } // cors if serverOptions.Cors && req.Method == http.MethodOptions { if globalOptions.Verbose { fmt.Println("CORS preflight") } if origin := req.Header.Get("Origin"); origin != "" { rsp.Header().Set("Access-Control-Allow-Origin", origin) if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" { rsp.Header().Set("Access-Control-Allow-Headers", headers) } if method := req.Header.Get("Access-Control-Request-Method"); method != "" { rsp.Header().Set("Access-Control-Allow-Method", method) } rsp.WriteHeader(200) return } else { if globalOptions.Verbose { fmt.Println("Preflight did not contain 'Origin' header!") } } } // send response if serverOptions.Body != "" { if serverOptions.Status == 204 { // body exists, so send a 200 response instead of 204 serverOptions.Status = 200 } rsp.WriteHeader(serverOptions.Status) fmt.Fprintf(rsp, serverOptions.Body) } else { // no body, so just write status header rsp.WriteHeader(serverOptions.Status) } }

Ignore Space Show notes View

src/server.go

/**
  Author: Mark George <mark.george@otago.ac.nz>
  License: Zero-Clause BSD License
*/

package main

import (
	"fmt"
	"net/http"
	"os"
	"strconv"
)

type ServerCommand struct {
	Port    int      `short:"p" long:"port" description:"Port to listen on." default:"8080"`
	Routes  []string `short:"r" long:"route" description:"Route which is made up of a path, a response body, and a response status, all separated by the pipe character.  Repeat for additional routes." default:"/|testing|200"`
	Cors    bool     `short:"c" long:"cors" description:"Enable Cross Origin Resource Sharing (CORS)."`
	Headers []string `short:"H" long:"header" description:"A header to add to response in the form name:value. Repeat for additional headers."`
}

var (
	serverOptions *ServerCommand
)

func (opts *ServerCommand) Execute(args []string) error {

serverOptions = opts

// parse custom headers if provided
	if len(opts.Headers) > 0 {
		for _, header := range opts.Headers {
			if _, _, err := parseHeader(header); err != nil {
				fmt.Println("The following header is not in the correct format: " + header + "\nCorrect format is: 'name:value'")
				os.Exit(1)
			}
		}
	}

fmt.Println("HTTP server listening on port " + strconv.Itoa(opts.Port) + "\n")

if len(opts.Routes) > 0 {
		fmt.Println("Routes:")
		for _, route := range opts.Routes {
			if path, _, _, err := parseRoute(route); err == nil {
				fmt.Println("  " + path)
				http.HandleFunc(path, serverRequestHandler)
			} else {
				fmt.Println("The following route is not in the correct format: " + route + "\nCorrect format is: \"/path|response body|status code\"")
				os.Exit(1)
			}
		}
	}

/* http.HandleFunc("/", serverRequestHandler) */

if err := http.ListenAndServe(":"+strconv.Itoa(opts.Port), nil); err != nil {
		fmt.Fprintf(os.Stderr, "Could not start server.  Is port %d available?\n", opts.Port)
		os.Exit(1)
	}

return nil
}

func serverRequestHandler(rsp http.ResponseWriter, req *http.Request) {

path := req.RequestURI
	body := bodies[path]
	code := statuses[path]

if globalOptions.BodiesOnly {
		showRequestBody(req)
	} else if globalOptions.HeadersOnly {
		showRequestHeaders(req)
	} else {
		showEntireRequest(req)
	}

// CORS
	if serverOptions.Cors && req.Method == http.MethodOptions {

if globalOptions.Verbose {
			fmt.Println("CORS preflight")
		}

if origin := req.Header.Get("Origin"); origin != "" {

rsp.Header().Set("Access-Control-Allow-Origin", origin)

if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" {
				rsp.Header().Set("Access-Control-Allow-Headers", headers)
			}

if method := req.Header.Get("Access-Control-Request-Method"); method != "" {
				rsp.Header().Set("Access-Control-Allow-Method", method)
			}

rsp.WriteHeader(200)

return

} else {
			fmt.Println("WARNING - CORS preflight did not contain 'Origin' header!")
		}
	}

// add custom headers if provided
	if len(serverOptions.Headers) > 0 {

for name, value := range headers {

if globalOptions.Verbose {
				fmt.Println("Adding response header - " + name + ": " + value)
			}

rsp.Header().Set(name, value)
		}
	}

// add status line
	rsp.WriteHeader(code)

// add body
	fmt.Fprintf(rsp, body)

}

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httputil"
	"os"
	"strconv"
	"time"
)

type ServerCommand struct {
	Body   string `short:"b" long:"body" description:"Body message to respond with."`
	Port   int    `short:"p" long:"port" description:"Port to listen on." default:"8080"`
	Status int    `short:"s" long:"status" description:"Status code to respond with." default:"204"`
	Cors   bool   `shot:"c" long:"cors" description:"Enable Cross Origin Resource Sharing (CORS)."`
}

var (
	serverOptions *ServerCommand
)

func (c *ServerCommand) Execute(args []string) error {

fmt.Println("HTTP server listening on port " + strconv.Itoa(c.Port) + "\n")

http.HandleFunc("/", serverRequestHandler)

serverOptions = c

if err := http.ListenAndServe(":"+strconv.Itoa(c.Port), nil); err != nil {
		fmt.Fprintf(os.Stderr, "Could not start server.  Is port %d available?\n", c.Port)
		os.Exit(1)
	}

return nil
}

func serverRequestHandler(rsp http.ResponseWriter, req *http.Request) {

if globalOptions.Verbose {

fmt.Printf("Received a %s request to %s\n", req.Method, req.RequestURI)
	}

fmt.Println(time.Now().Format(time.StampMilli))

if globalOptions.BodiesOnly {
		body, _ := ioutil.ReadAll(req.Body)
		fmt.Println(string(body[:]))

} else if globalOptions.HeadersOnly {
		fmt.Println(req.Method + " " + req.URL.Path + " " + req.Proto)
		for k := range req.Header {
			fmt.Println(k + ": " + req.Header[k][0])
		}
		// TODO

} else {
		// dump entire request
		dump, _ := httputil.DumpRequest(req, true)
		fmt.Println(string(dump[:]))
	}

// cors
	if serverOptions.Cors && req.Method == http.MethodOptions {
		if globalOptions.Verbose {
			fmt.Println("CORS preflight")
		}

if origin := req.Header.Get("Origin"); origin != "" {

rsp.Header().Set("Access-Control-Allow-Origin", origin)

if headers := req.Header.Get("Access-Control-Request-Headers"); headers != "" {
				rsp.Header().Set("Access-Control-Allow-Headers", headers)
			}

if method := req.Header.Get("Access-Control-Request-Method"); method != "" {
				rsp.Header().Set("Access-Control-Allow-Method", method)
			}

rsp.WriteHeader(200)

return

} else {
			if globalOptions.Verbose {
				fmt.Println("Preflight did not contain 'Origin' header!")
			}
		}
	}

// send response
	if serverOptions.Body != "" {
		if serverOptions.Status == 204 {
			// body exists, so send a 200 response instead of 204
			serverOptions.Status = 200
		}
		rsp.WriteHeader(serverOptions.Status)
		fmt.Fprintf(rsp, serverOptions.Body)
	} else {
		// no body, so just write status header
		rsp.WriteHeader(serverOptions.Status)
	}

}

Show line notes below