{{ txn.Req.MethodPath }} |
{{ txn.Resp.Status }} | {{ txn.Duration }} |
{{ Req.RawText }}{{ Req.RawBytes }}{{ Resp.RawText }}{{ Resp.RawBytes }}| {{ key }} | ' + '{{ value }} | ' + '
|---|
Unable to initiate connection to %s. A web server must be running on port %s to complete the tunnel.
` ) type ClientModel struct { log.Logger id string tunnels map[string]mvc.Tunnel serverVersion string metrics *ClientMetrics updateStatus mvc.UpdateStatus connStatus mvc.ConnStatus protoMap map[string]proto.Protocol protocols []proto.Protocol ctl mvc.Controller serverAddr string proxyUrl string authToken string tlsConfig *tls.Config tunnelConfig map[string]*TunnelConfiguration configPath string } func newClientModel(config *Configuration, ctl mvc.Controller) *ClientModel { protoMap := make(map[string]proto.Protocol) protoMap["http"] = proto.NewHttp() protoMap["https"] = protoMap["http"] protoMap["tcp"] = proto.NewTcp() protocols := []proto.Protocol{protoMap["http"], protoMap["tcp"]} // configure TLS var tlsConfig *tls.Config if config.TrustHostRootCerts { tlsConfig = &tls.Config{} } else { var err error if tlsConfig, err = LoadTLSConfig(rootCrtPaths); err != nil { panic(err) } } return &ClientModel{ Logger: log.NewPrefixLogger("client"), // server address serverAddr: config.ServerAddr, // proxy address proxyUrl: config.HttpProxy, // auth token authToken: config.AuthToken, // connection status connStatus: mvc.ConnConnecting, // update status updateStatus: mvc.UpdateNone, // metrics metrics: NewClientMetrics(), // protocols protoMap: protoMap, // protocol list protocols: protocols, // open tunnels tunnels: make(map[string]mvc.Tunnel), // controller ctl: ctl, // tls configuration tlsConfig: tlsConfig, // tunnel configuration tunnelConfig: config.Tunnels, // config path configPath: config.Path, } } // mvc.State interface func (c ClientModel) GetProtocols() []proto.Protocol { return c.protocols } func (c ClientModel) GetClientVersion() string { return version.MajorMinor() } func (c ClientModel) GetServerVersion() string { return c.serverVersion } func (c ClientModel) GetTunnels() []mvc.Tunnel { tunnels := make([]mvc.Tunnel, 0) for _, t := range c.tunnels { tunnels = append(tunnels, t) } return tunnels } func (c ClientModel) GetConnStatus() mvc.ConnStatus { return c.connStatus } func (c ClientModel) GetUpdateStatus() mvc.UpdateStatus { return c.updateStatus } func (c ClientModel) GetConnectionMetrics() (metrics.Meter, metrics.Timer) { return c.metrics.connMeter, c.metrics.connTimer } func (c ClientModel) GetBytesInMetrics() (metrics.Counter, metrics.Histogram) { return c.metrics.bytesInCount, c.metrics.bytesIn } func (c ClientModel) GetBytesOutMetrics() (metrics.Counter, metrics.Histogram) { return c.metrics.bytesOutCount, c.metrics.bytesOut } func (c ClientModel) SetUpdateStatus(updateStatus mvc.UpdateStatus) { c.updateStatus = updateStatus c.update() } // mvc.Model interface func (c *ClientModel) PlayRequest(tunnel mvc.Tunnel, payload []byte) { var localConn conn.Conn localConn, err := conn.Dial(tunnel.LocalAddr, "prv", nil) if err != nil { c.Warn("Failed to open private leg to %s: %v", tunnel.LocalAddr, err) return } defer localConn.Close() localConn = tunnel.Protocol.WrapConn(localConn, mvc.ConnectionContext{Tunnel: tunnel, ClientAddr: "127.0.0.1"}) localConn.Write(payload) ioutil.ReadAll(localConn) } func (c *ClientModel) Shutdown() { } func (c *ClientModel) update() { c.ctl.Update(c) } func (c *ClientModel) Run() { // how long we should wait before we reconnect maxWait := 30 * time.Second wait := 1 * time.Second for { // run the control channel c.control() // control oonly returns when a failure has occurred, so we're going to try to reconnect if c.connStatus == mvc.ConnOnline { wait = 1 * time.Second } log.Info("Waiting %d seconds before reconnecting", int(wait.Seconds())) time.Sleep(wait) // exponentially increase wait time wait = 2 * wait wait = time.Duration(math.Min(float64(wait), float64(maxWait))) c.connStatus = mvc.ConnReconnecting c.update() } } // Establishes and manages a tunnel control connection with the server func (c *ClientModel) control() { defer func() { if r := recover(); r != nil { log.Error("control recovering from failure %v", r) } }() // establish control channel var ( ctlConn conn.Conn err error ) if c.proxyUrl == "" { // simple non-proxied case, just connect to the server ctlConn, err = conn.Dial(c.serverAddr, "ctl", c.tlsConfig) } else { ctlConn, err = conn.DialHttpProxy(c.proxyUrl, c.serverAddr, "ctl", c.tlsConfig) } if err != nil { panic(err) } defer ctlConn.Close() // authenticate with the server auth := &msg.Auth{ ClientId: c.id, OS: runtime.GOOS, Arch: runtime.GOARCH, Version: version.Proto, MmVersion: version.MajorMinor(), User: c.authToken, } if err = msg.WriteMsg(ctlConn, auth); err != nil { panic(err) } // wait for the server to authenticate us var authResp msg.AuthResp if err = msg.ReadMsgInto(ctlConn, &authResp); err != nil { panic(err) } if authResp.Error != "" { emsg := fmt.Sprintf("Failed to authenticate to server: %s", authResp.Error) c.ctl.Shutdown(emsg) return } c.id = authResp.ClientId c.serverVersion = authResp.MmVersion c.Info("Authenticated with server, client id: %v", c.id) c.update() if err = SaveAuthToken(c.configPath, c.authToken); err != nil { c.Error("Failed to save auth token: %v", err) } // request tunnels reqIdToTunnelConfig := make(map[string]*TunnelConfiguration) for _, config := range c.tunnelConfig { // create the protocol list to ask for var protocols []string for proto, _ := range config.Protocols { protocols = append(protocols, proto) } reqTunnel := &msg.ReqTunnel{ ReqId: util.RandId(8), Protocol: strings.Join(protocols, "+"), Hostname: config.Hostname, Subdomain: config.Subdomain, HttpAuth: config.HttpAuth, RemotePort: config.RemotePort, } // send the tunnel request if err = msg.WriteMsg(ctlConn, reqTunnel); err != nil { panic(err) } // save request id association so we know which local address // to proxy to later reqIdToTunnelConfig[reqTunnel.ReqId] = config } // start the heartbeat lastPong := time.Now().UnixNano() c.ctl.Go(func() { c.heartbeat(&lastPong, ctlConn) }) // main control loop for { var rawMsg msg.Message if rawMsg, err = msg.ReadMsg(ctlConn); err != nil { panic(err) } switch m := rawMsg.(type) { case *msg.ReqProxy: c.ctl.Go(c.proxy) case *msg.Pong: atomic.StoreInt64(&lastPong, time.Now().UnixNano()) case *msg.NewTunnel: if m.Error != "" { emsg := fmt.Sprintf("Server failed to allocate tunnel: %s", m.Error) c.Error(emsg) c.ctl.Shutdown(emsg) continue } tunnel := mvc.Tunnel{ PublicUrl: m.Url, LocalAddr: reqIdToTunnelConfig[m.ReqId].Protocols[m.Protocol], Protocol: c.protoMap[m.Protocol], } c.tunnels[tunnel.PublicUrl] = tunnel c.connStatus = mvc.ConnOnline c.Info("Tunnel established at %v", tunnel.PublicUrl) c.update() default: ctlConn.Warn("Ignoring unknown control message %v ", m) } } } // Establishes and manages a tunnel proxy connection with the server func (c *ClientModel) proxy() { var ( remoteConn conn.Conn err error ) if c.proxyUrl == "" { remoteConn, err = conn.Dial(c.serverAddr, "pxy", c.tlsConfig) } else { remoteConn, err = conn.DialHttpProxy(c.proxyUrl, c.serverAddr, "pxy", c.tlsConfig) } if err != nil { log.Error("Failed to establish proxy connection: %v", err) return } defer remoteConn.Close() err = msg.WriteMsg(remoteConn, &msg.RegProxy{ClientId: c.id}) if err != nil { remoteConn.Error("Failed to write RegProxy: %v", err) return } // wait for the server to ack our register var startPxy msg.StartProxy if err = msg.ReadMsgInto(remoteConn, &startPxy); err != nil { remoteConn.Error("Server failed to write StartProxy: %v", err) return } tunnel, ok := c.tunnels[startPxy.Url] if !ok { remoteConn.Error("Couldn't find tunnel for proxy: %s", startPxy.Url) return } // start up the private connection start := time.Now() localConn, err := conn.Dial(tunnel.LocalAddr, "prv", nil) if err != nil { remoteConn.Warn("Failed to open private leg %s: %v", tunnel.LocalAddr, err) if tunnel.Protocol.GetName() == "http" { // try to be helpful when you're in HTTP mode and a human might see the output badGatewayBody := fmt.Sprintf(BadGateway, tunnel.PublicUrl, tunnel.LocalAddr, tunnel.LocalAddr) remoteConn.Write([]byte(fmt.Sprintf(`HTTP/1.0 502 Bad Gateway Content-Type: text/html Content-Length: %d %s`, len(badGatewayBody), badGatewayBody))) } return } defer localConn.Close() m := c.metrics m.proxySetupTimer.Update(time.Since(start)) m.connMeter.Mark(1) c.update() m.connTimer.Time(func() { localConn := tunnel.Protocol.WrapConn(localConn, mvc.ConnectionContext{Tunnel: tunnel, ClientAddr: startPxy.ClientAddr}) bytesIn, bytesOut := conn.Join(localConn, remoteConn) m.bytesIn.Update(bytesIn) m.bytesOut.Update(bytesOut) m.bytesInCount.Inc(bytesIn) m.bytesOutCount.Inc(bytesOut) }) c.update() } // Hearbeating to ensure our connection ngrokd is still live func (c *ClientModel) heartbeat(lastPongAddr *int64, conn conn.Conn) { lastPing := time.Unix(atomic.LoadInt64(lastPongAddr)-1, 0) ping := time.NewTicker(pingInterval) pongCheck := time.NewTicker(time.Second) defer func() { conn.Close() ping.Stop() pongCheck.Stop() }() for { select { case <-pongCheck.C: lastPong := time.Unix(0, atomic.LoadInt64(lastPongAddr)) needPong := lastPong.Sub(lastPing) < 0 pongLatency := time.Since(lastPing) if needPong && pongLatency > maxPongLatency { c.Info("Last ping: %v, Last pong: %v", lastPing, lastPong) c.Info("Connection stale, haven't gotten PongMsg in %d seconds", int(pongLatency.Seconds())) return } case <-ping.C: err := msg.WriteMsg(conn, &msg.Ping{}) if err != nil { conn.Debug("Got error %v when writing PingMsg", err) return } lastPing = time.Now() } } } ngrok-1.6+dfsg.orig/src/ngrok/client/config.go 0000644 0000000 0000000 00000015540 12232501726 020042 0 ustar root root package client import ( "fmt" "io/ioutil" "launchpad.net/goyaml" "net" "net/url" "ngrok/log" "os" "os/user" "path" "regexp" "strconv" "strings" ) type Configuration struct { HttpProxy string `yaml:"http_proxy,omitempty"` ServerAddr string `yaml:"server_addr,omitempty"` InspectAddr string `yaml:"inspect_addr,omitempty"` TrustHostRootCerts bool `yaml:"trust_host_root_certs,omitempty"` AuthToken string `yaml:"auth_token,omitempty"` Tunnels map[string]*TunnelConfiguration `yaml:"tunnels,omitempty"` LogTo string `yaml:"-"` Path string `yaml:"-"` } type TunnelConfiguration struct { Subdomain string `yaml:"subdomain,omitempty"` Hostname string `yaml:"hostname,omitempty"` Protocols map[string]string `yaml:"proto,omitempty"` HttpAuth string `yaml:"auth,omitempty"` RemotePort uint16 `yaml:"remote_port,omitempty"` } func LoadConfiguration(opts *Options) (config *Configuration, err error) { configPath := opts.config if configPath == "" { configPath = defaultPath() } log.Info("Reading configuration file %s", configPath) configBuf, err := ioutil.ReadFile(configPath) if err != nil { // failure to read a configuration file is only a fatal error if // the user specified one explicitly if opts.config != "" { err = fmt.Errorf("Failed to read configuration file %s: %v", configPath, err) return } } // deserialize/parse the config config = new(Configuration) if err = goyaml.Unmarshal(configBuf, &config); err != nil { err = fmt.Errorf("Error parsing configuration file %s: %v", configPath, err) return } // try to parse the old .ngrok format for backwards compatibility matched := false content := strings.TrimSpace(string(configBuf)) if matched, err = regexp.MatchString("^[0-9a-zA-Z_\\-!]+$", content); err != nil { return } else if matched { config = &Configuration{AuthToken: content} } // set configuration defaults if config.ServerAddr == "" { config.ServerAddr = defaultServerAddr } if config.InspectAddr == "" { config.InspectAddr = "127.0.0.1:4040" } if config.HttpProxy == "" { config.HttpProxy = os.Getenv("http_proxy") } // validate and normalize configuration if config.InspectAddr != "disabled" { if config.InspectAddr, err = normalizeAddress(config.InspectAddr, "inspect_addr"); err != nil { return } } if config.ServerAddr, err = normalizeAddress(config.ServerAddr, "server_addr"); err != nil { return } if config.HttpProxy != "" { var proxyUrl *url.URL if proxyUrl, err = url.Parse(config.HttpProxy); err != nil { return } else { if proxyUrl.Scheme != "http" && proxyUrl.Scheme != "https" { err = fmt.Errorf("Proxy url scheme must be 'http' or 'https', got %v", proxyUrl.Scheme) return } } } for name, t := range config.Tunnels { if t == nil || t.Protocols == nil || len(t.Protocols) == 0 { err = fmt.Errorf("Tunnel %s does not specify any protocols to tunnel.", name) return } for k, addr := range t.Protocols { tunnelName := fmt.Sprintf("for tunnel %s[%s]", name, k) if t.Protocols[k], err = normalizeAddress(addr, tunnelName); err != nil { return } if err = validateProtocol(k, tunnelName); err != nil { return } } // use the name of the tunnel as the subdomain if none is specified if t.Hostname == "" && t.Subdomain == "" { // XXX: a crude heuristic, really we should be checking if the last part // is a TLD if len(strings.Split(name, ".")) > 1 { t.Hostname = name } else { t.Subdomain = name } } } // override configuration with command-line options config.LogTo = opts.logto config.Path = configPath if opts.authtoken != "" { config.AuthToken = opts.authtoken } switch opts.command { // start a single tunnel, the default, simple ngrok behavior case "default": config.Tunnels = make(map[string]*TunnelConfiguration) config.Tunnels["default"] = &TunnelConfiguration{ Subdomain: opts.subdomain, Hostname: opts.hostname, HttpAuth: opts.httpauth, Protocols: make(map[string]string), } for _, proto := range strings.Split(opts.protocol, "+") { if err = validateProtocol(proto, "default"); err != nil { return } if config.Tunnels["default"].Protocols[proto], err = normalizeAddress(opts.args[0], ""); err != nil { return } } // start tunnels case "start": if len(opts.args) == 0 { err = fmt.Errorf("You must specify at least one tunnel to start") return } requestedTunnels := make(map[string]bool) for _, arg := range opts.args { requestedTunnels[arg] = true if _, ok := config.Tunnels[arg]; !ok { err = fmt.Errorf("Requested to start tunnel %s which is not defined in the config file.", arg) return } } for name, _ := range config.Tunnels { if !requestedTunnels[name] { delete(config.Tunnels, name) } } default: err = fmt.Errorf("Unknown command: %s", opts.command) return } return } func defaultPath() string { user, err := user.Current() // user.Current() does not work on linux when cross compilling because // it requires CGO; use os.Getenv("HOME") hack until we compile natively homeDir := os.Getenv("HOME") if err != nil { log.Warn("Failed to get user's home directory: %s. Using $HOME: %s", err.Error(), homeDir) } else { homeDir = user.HomeDir } return path.Join(homeDir, ".ngrok") } func normalizeAddress(addr string, propName string) (string, error) { // normalize port to address if _, err := strconv.Atoi(addr); err == nil { addr = ":" + addr } tcpAddr, err := net.ResolveTCPAddr("tcp", addr) if err != nil { return "", fmt.Errorf("Invalid address %s '%s': %s", propName, addr, err.Error()) } if tcpAddr.IP == nil { tcpAddr.IP = net.ParseIP("127.0.0.1") } return tcpAddr.String(), nil } func validateProtocol(proto, propName string) (err error) { switch proto { case "http", "https", "http+https", "tcp": default: err = fmt.Errorf("Invalid protocol for %s: %s", propName, proto) } return } func SaveAuthToken(configPath, authtoken string) (err error) { // empty configuration by default for the case that we can't read it c := new(Configuration) // read the configuration oldConfigBytes, err := ioutil.ReadFile(configPath) if err == nil { // unmarshal if we successfully read the configuration file if err = goyaml.Unmarshal(oldConfigBytes, c); err != nil { return } } // no need to save, the authtoken is already the correct value if c.AuthToken == authtoken { return } // update auth token c.AuthToken = authtoken // rewrite configuration newConfigBytes, err := goyaml.Marshal(c) if err != nil { return } err = ioutil.WriteFile(configPath, newConfigBytes, 0600) return } ngrok-1.6+dfsg.orig/src/ngrok/client/assets/ 0000755 0000000 0000000 00000000000 12232501726 017543 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/client/assets/assets_debug.go 0000644 0000000 0000000 00000000213 12232501726 022536 0 ustar root root // +build !release package assets import ( "io/ioutil" ) func ReadAsset(name string) ([]byte, error) { return ioutil.ReadFile(name) } ngrok-1.6+dfsg.orig/src/ngrok/client/main.go 0000644 0000000 0000000 00000001073 12232501726 017515 0 ustar root root package client import ( "fmt" "math/rand" "ngrok/log" "ngrok/util" "os" ) func Main() { // parse options opts, err := parseArgs() if err != nil { fmt.Println(err) os.Exit(1) } // set up logging log.LogTo(opts.logto) // read configuration file config, err := LoadConfiguration(opts) if err != nil { fmt.Println(err) os.Exit(1) } // seed random number generator seed, err := util.RandomSeed() if err != nil { fmt.Printf("Couldn't securely seed the random number generator!") os.Exit(1) } rand.Seed(seed) NewController().Run(config) } ngrok-1.6+dfsg.orig/src/ngrok/client/mvc/ 0000755 0000000 0000000 00000000000 12232501726 017026 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/client/mvc/model.go 0000644 0000000 0000000 00000000147 12232501726 020457 0 ustar root root package mvc type Model interface { Run() Shutdown() PlayRequest(tunnel Tunnel, payload []byte) } ngrok-1.6+dfsg.orig/src/ngrok/client/mvc/state.go 0000644 0000000 0000000 00000001505 12232501726 020476 0 ustar root root package mvc import ( metrics "github.com/inconshreveable/go-metrics" "ngrok/proto" ) type UpdateStatus int const ( UpdateNone = -1 * iota UpdateInstalling UpdateReady UpdateAvailable ) type ConnStatus int const ( ConnConnecting = iota ConnReconnecting ConnOnline ) type Tunnel struct { PublicUrl string Protocol proto.Protocol LocalAddr string } type ConnectionContext struct { Tunnel Tunnel ClientAddr string } type State interface { GetClientVersion() string GetServerVersion() string GetTunnels() []Tunnel GetProtocols() []proto.Protocol GetUpdateStatus() UpdateStatus GetConnStatus() ConnStatus GetConnectionMetrics() (metrics.Meter, metrics.Timer) GetBytesInMetrics() (metrics.Counter, metrics.Histogram) GetBytesOutMetrics() (metrics.Counter, metrics.Histogram) SetUpdateStatus(UpdateStatus) } ngrok-1.6+dfsg.orig/src/ngrok/client/mvc/view.go 0000644 0000000 0000000 00000000061 12232501726 020324 0 ustar root root package mvc type View interface { Shutdown() } ngrok-1.6+dfsg.orig/src/ngrok/client/mvc/controller.go 0000644 0000000 0000000 00000001063 12232501726 021540 0 ustar root root package mvc import ( "ngrok/util" ) type Controller interface { // how the model communicates that it has changed state Update(State) // instructs the controller to shut the app down Shutdown(message string) // PlayRequest instructs the model to play requests PlayRequest(tunnel Tunnel, payload []byte) // A channel of updates Updates() *util.Broadcast // returns the current state State() State // safe wrapper for running go-routines Go(fn func()) // the address where the web inspection interface is running GetWebInspectAddr() string } ngrok-1.6+dfsg.orig/src/ngrok/client/update_debug.go 0000644 0000000 0000000 00000000245 12232501726 021221 0 ustar root root // +build !release,!autoupdate package client import ( "ngrok/client/mvc" ) // no auto-updating in debug mode func autoUpdate(state mvc.State, token string) { } ngrok-1.6+dfsg.orig/src/ngrok/client/update_release.go 0000644 0000000 0000000 00000005623 12232501726 021560 0 ustar root root // +build release autoupdate package client import ( update "github.com/inconshreveable/go-update" "net/http" "net/url" "ngrok/client/mvc" "ngrok/log" "ngrok/version" "runtime" "time" ) const ( updateEndpoint = "https://dl.ngrok.com/update" checkEndpoint = "https://dl.ngrok.com/update/check" ) func progressWatcher(s mvc.State, progress chan int, complete chan int) { for { select { case pct, ok := <-progress: if !ok { close(complete) return } else if pct == 100 { s.SetUpdateStatus(mvc.UpdateInstalling) close(complete) return } else { if pct%25 == 0 { log.Info("Downloading update %d%% complete", pct) } s.SetUpdateStatus(mvc.UpdateStatus(pct)) } } } } func autoUpdate(s mvc.State, token string) { tryAgain := true params := make(url.Values) params.Add("version", version.MajorMinor()) params.Add("os", runtime.GOOS) params.Add("arch", runtime.GOARCH) params.Add("user", token) updateUrl := updateEndpoint + "?" + params.Encode() checkUrl := checkEndpoint + "?" + params.Encode() update := func() { log.Info("Checking for update") available, err := update.NewDownload(checkUrl).Check() if err != nil { log.Error("Error while checking for update: %v", err) return } if !available { log.Info("No update available") return } // stop trying after a single download attempt // XXX: improve this so the we can: // 1. safely update multiple times // 2. only retry after a network connection failure tryAgain = false download := update.NewDownload(updateUrl) downloadComplete := make(chan int) go progressWatcher(s, download.Progress, downloadComplete) log.Info("Trying to update . . .") err, errRecover := download.GetAndUpdate() <-downloadComplete if err != nil { // log error to console log.Error("Error while updating ngrok: %v", err) if errRecover != nil { log.Error("Error while recovering from failed ngrok update, your binary may be missing: %v", errRecover.Error()) params.Add("errorRecover", errRecover.Error()) } // log error to ngrok.com's servers for debugging purposes params.Add("error", err.Error()) resp, reportErr := http.PostForm("https://dl.ngrok.com/update/error", params) if err != nil { log.Error("Error while reporting update error: %v, %v", err, reportErr) } resp.Body.Close() // tell the user to update manually s.SetUpdateStatus(mvc.UpdateAvailable) } else { if !download.Available { // this is the way the server tells us to update manually log.Info("Server wants us to update manually") s.SetUpdateStatus(mvc.UpdateAvailable) } else { // tell the user the update is ready log.Info("Update ready!") s.SetUpdateStatus(mvc.UpdateReady) } } return } // try to update immediately and then at a set interval update() for _ = range time.Tick(updateCheckInterval) { if !tryAgain { break } update() } } ngrok-1.6+dfsg.orig/src/ngrok/client/views/ 0000755 0000000 0000000 00000000000 12232501726 017376 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/client/views/term/ 0000755 0000000 0000000 00000000000 12232501726 020345 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/client/views/term/area.go 0000644 0000000 0000000 00000001606 12232501726 021607 0 ustar root root // shared internal functions for handling output to the terminal package term import ( "fmt" termbox "github.com/nsf/termbox-go" ) const ( fgColor = termbox.ColorWhite bgColor = termbox.ColorDefault ) type area struct { // top-left corner x, y int // size of the area w, h int // default colors fgColor, bgColor termbox.Attribute } func NewArea(x, y, w, h int) *area { return &area{x, y, w, h, fgColor, bgColor} } func (a *area) Clear() { for i := 0; i < a.w; i++ { for j := 0; j < a.h; j++ { termbox.SetCell(a.x+i, a.y+j, ' ', a.fgColor, a.bgColor) } } } func (a *area) APrintf(fg termbox.Attribute, x, y int, arg0 string, args ...interface{}) { s := fmt.Sprintf(arg0, args...) for i, ch := range s { termbox.SetCell(a.x+x+i, a.y+y, ch, fg, bgColor) } } func (a *area) Printf(x, y int, arg0 string, args ...interface{}) { a.APrintf(a.fgColor, x, y, arg0, args...) } ngrok-1.6+dfsg.orig/src/ngrok/client/views/term/http.go 0000644 0000000 0000000 00000005113 12232501726 021653 0 ustar root root package term import ( termbox "github.com/nsf/termbox-go" "ngrok/client/mvc" "ngrok/log" "ngrok/proto" "ngrok/util" "unicode/utf8" ) const ( size = 10 pathMaxLength = 25 ) type HttpView struct { log.Logger *area httpProto *proto.Http HttpRequests *util.Ring shutdown chan int termView *TermView } func colorFor(status string) termbox.Attribute { switch status[0] { case '3': return termbox.ColorCyan case '4': return termbox.ColorYellow case '5': return termbox.ColorRed default: } return termbox.ColorWhite } func newTermHttpView(ctl mvc.Controller, termView *TermView, proto *proto.Http, x, y int) *HttpView { v := &HttpView{ httpProto: proto, HttpRequests: util.NewRing(size), area: NewArea(x, y, 70, size+5), shutdown: make(chan int), termView: termView, Logger: log.NewPrefixLogger("view", "term", "http"), } ctl.Go(v.Run) return v } func (v *HttpView) Run() { updates := v.httpProto.Txns.Reg() for { select { case txn := <-updates: v.Debug("Got HTTP update") if txn.(*proto.HttpTxn).Resp == nil { v.HttpRequests.Add(txn) } v.Render() } } } func (v *HttpView) Render() { v.Clear() v.Printf(0, 0, "HTTP Requests") v.Printf(0, 1, "-------------") for i, obj := range v.HttpRequests.Slice() { txn := obj.(*proto.HttpTxn) path := truncatePath(txn.Req.URL.Path) v.Printf(0, 3+i, "%s %v", txn.Req.Method, path) if txn.Resp != nil { v.APrintf(colorFor(txn.Resp.Status), 30, 3+i, "%s", txn.Resp.Status) } } v.termView.Flush() } func (v *HttpView) Shutdown() { close(v.shutdown) } func truncatePath(path string) string { // Truncate all long strings based on rune count if utf8.RuneCountInString(path) > pathMaxLength { path = string([]rune(path)[:pathMaxLength]) } // By this point, len(path) should be < pathMaxLength if we're dealing with single-byte runes. // Otherwise, we have a multi-byte string and need to calculate the size of each rune and // truncate manually. // // This is a workaround for a bug in termbox-go. Remove it when this issue is fixed: // https://github.com/nsf/termbox-go/pull/21 if len(path) > pathMaxLength { out := make([]byte, pathMaxLength, pathMaxLength) length := 0 for { r, size := utf8.DecodeRuneInString(path[length:]) if r == utf8.RuneError && size == 1 { break } // utf8.EncodeRune expects there to be enough room to store the full size of the rune if length+size <= pathMaxLength { utf8.EncodeRune(out[length:], r) length += size } else { break } } path = string(out[:length]) } return path } ngrok-1.6+dfsg.orig/src/ngrok/client/views/term/view.go 0000644 0000000 0000000 00000007213 12232501726 021651 0 ustar root root // interactive terminal interface for local clients package term import ( termbox "github.com/nsf/termbox-go" "ngrok/client/mvc" "ngrok/log" "ngrok/proto" "ngrok/util" "time" ) type TermView struct { ctl mvc.Controller updates chan interface{} flush chan int shutdown chan int redraw *util.Broadcast subviews []mvc.View log.Logger *area } func NewTermView(ctl mvc.Controller) *TermView { // initialize terminal display termbox.Init() w, _ := termbox.Size() v := &TermView{ ctl: ctl, updates: ctl.Updates().Reg(), redraw: util.NewBroadcast(), flush: make(chan int), shutdown: make(chan int), Logger: log.NewPrefixLogger("view", "term"), area: NewArea(0, 0, w, 10), } ctl.Go(v.run) ctl.Go(v.input) return v } func connStatusRepr(status mvc.ConnStatus) (string, termbox.Attribute) { switch status { case mvc.ConnConnecting: return "connecting", termbox.ColorCyan case mvc.ConnReconnecting: return "reconnecting", termbox.ColorRed case mvc.ConnOnline: return "online", termbox.ColorGreen } return "unknown", termbox.ColorWhite } func (v *TermView) draw() { state := v.ctl.State() v.Clear() // quit instructions quitMsg := "(Ctrl+C to quit)" v.Printf(v.w-len(quitMsg), 0, quitMsg) // new version message updateStatus := state.GetUpdateStatus() var updateMsg string switch updateStatus { case mvc.UpdateNone: updateMsg = "" case mvc.UpdateInstalling: updateMsg = "ngrok is updating" case mvc.UpdateReady: updateMsg = "ngrok has updated: restart ngrok for the new version" case mvc.UpdateAvailable: updateMsg = "new version available at https://ngrok.com" default: pct := float64(updateStatus) / 100.0 const barLength = 25 full := int(barLength * pct) bar := make([]byte, barLength+2) bar[0] = '[' bar[barLength+1] = ']' for i := 0; i < 25; i++ { if i <= full { bar[i+1] = '#' } else { bar[i+1] = ' ' } } updateMsg = "Downloading update: " + string(bar) } if updateMsg != "" { v.APrintf(termbox.ColorYellow, 30, 0, updateMsg) } v.APrintf(termbox.ColorBlue|termbox.AttrBold, 0, 0, "ngrok") statusStr, statusColor := connStatusRepr(state.GetConnStatus()) v.APrintf(statusColor, 0, 2, "%-30s%s", "Tunnel Status", statusStr) v.Printf(0, 3, "%-30s%s/%s", "Version", state.GetClientVersion(), state.GetServerVersion()) var i int = 4 for _, t := range state.GetTunnels() { v.Printf(0, i, "%-30s%s -> %s", "Forwarding", t.PublicUrl, t.LocalAddr) i++ } v.Printf(0, i+0, "%-30s%s", "Web Interface", v.ctl.GetWebInspectAddr()) connMeter, connTimer := state.GetConnectionMetrics() v.Printf(0, i+1, "%-30s%d", "# Conn", connMeter.Count()) msec := float64(time.Millisecond) v.Printf(0, i+2, "%-30s%.2fms", "Avg Conn Time", connTimer.Mean()/msec) termbox.Flush() } func (v *TermView) run() { defer close(v.shutdown) defer termbox.Close() redraw := v.redraw.Reg() defer v.redraw.UnReg(redraw) v.draw() for { v.Debug("Waiting for update") select { case <-v.flush: termbox.Flush() case <-v.updates: v.draw() case <-redraw: v.draw() case <-v.shutdown: return } } } func (v *TermView) Shutdown() { v.shutdown <- 1 <-v.shutdown } func (v *TermView) Flush() { v.flush <- 1 } func (v *TermView) NewHttpView(p *proto.Http) *HttpView { return newTermHttpView(v.ctl, v, p, 0, 12) } func (v *TermView) input() { for { ev := termbox.PollEvent() switch ev.Type { case termbox.EventKey: switch ev.Key { case termbox.KeyCtrlC: v.Info("Got quit command") v.ctl.Shutdown("") } case termbox.EventResize: v.Info("Resize event, redrawing") v.redraw.In() <- 1 case termbox.EventError: panic(ev.Err) } } } ngrok-1.6+dfsg.orig/src/ngrok/client/views/web/ 0000755 0000000 0000000 00000000000 12232501726 020153 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/client/views/web/http.go 0000644 0000000 0000000 00000014617 12232501726 021472 0 ustar root root // interative web user interface package web import ( "encoding/base64" "encoding/json" "encoding/xml" "html/template" "net/http" "net/http/httputil" "net/url" "ngrok/client/assets" "ngrok/client/mvc" "ngrok/log" "ngrok/proto" "ngrok/util" "strings" "unicode/utf8" ) type SerializedTxn struct { Id string Duration int64 Start int64 ConnCtx mvc.ConnectionContext *proto.HttpTxn `json:"-"` Req SerializedRequest Resp SerializedResponse } type SerializedBody struct { RawContentType string ContentType string Text string Length int Error string ErrorOffset int Form url.Values } type SerializedRequest struct { Raw string MethodPath string Params url.Values Header http.Header Body SerializedBody Binary bool } type SerializedResponse struct { Raw string Status string Header http.Header Body SerializedBody Binary bool } type WebHttpView struct { log.Logger webview *WebView ctl mvc.Controller httpProto *proto.Http state chan SerializedUiState HttpRequests *util.Ring idToTxn map[string]*SerializedTxn } type SerializedUiState struct { Tunnels []mvc.Tunnel } type SerializedPayload struct { Txns []interface{} UiState SerializedUiState } func newWebHttpView(ctl mvc.Controller, wv *WebView, proto *proto.Http) *WebHttpView { whv := &WebHttpView{ Logger: log.NewPrefixLogger("view", "web", "http"), webview: wv, ctl: ctl, httpProto: proto, idToTxn: make(map[string]*SerializedTxn), HttpRequests: util.NewRing(20), } ctl.Go(whv.updateHttp) whv.register() return whv } type XMLDoc struct { data []byte `xml:",innerxml"` } func makeBody(h http.Header, body []byte) SerializedBody { b := SerializedBody{ Length: len(body), Text: base64.StdEncoding.EncodeToString(body), ErrorOffset: -1, } // some errors like XML errors only give a line number // and not an exact offset offsetForLine := func(line int) int { lines := strings.SplitAfterN(b.Text, "\n", line) return b.Length - len(lines[len(lines)-1]) } var err error b.RawContentType = h.Get("Content-Type") if b.RawContentType != "" { b.ContentType = strings.TrimSpace(strings.Split(b.RawContentType, ";")[0]) switch b.ContentType { case "application/xml", "text/xml": err = xml.Unmarshal(body, new(XMLDoc)) if err != nil { if syntaxError, ok := err.(*xml.SyntaxError); ok { // xml syntax errors only give us a line number, so we // count to find an offset b.ErrorOffset = offsetForLine(syntaxError.Line) } } case "application/json": err = json.Unmarshal(body, new(json.RawMessage)) if err != nil { if syntaxError, ok := err.(*json.SyntaxError); ok { b.ErrorOffset = int(syntaxError.Offset) } } case "application/x-www-form-urlencoded": b.Form, err = url.ParseQuery(string(body)) } } if err != nil { b.Error = err.Error() } return b } func (whv *WebHttpView) updateHttp() { // open channels for incoming http state changes // and broadbasts txnUpdates := whv.httpProto.Txns.Reg() for txn := range txnUpdates { // XXX: it's not safe for proto.Http and this code // to be accessing txn and txn.(req/resp) without synchronization htxn := txn.(*proto.HttpTxn) // we haven't processed this transaction yet if we haven't set the // user data if htxn.UserCtx == nil { rawReq, err := httputil.DumpRequestOut(htxn.Req.Request, true) if err != nil { whv.Error("Failed to dump request: %v", err) continue } body := makeBody(htxn.Req.Header, htxn.Req.BodyBytes) whtxn := &SerializedTxn{ Id: util.RandId(8), HttpTxn: htxn, Req: SerializedRequest{ MethodPath: htxn.Req.Method + " " + htxn.Req.URL.Path, Raw: base64.StdEncoding.EncodeToString(rawReq), Params: htxn.Req.URL.Query(), Header: htxn.Req.Header, Body: body, Binary: !utf8.Valid(rawReq), }, Start: htxn.Start.Unix(), ConnCtx: htxn.ConnUserCtx.(mvc.ConnectionContext), } htxn.UserCtx = whtxn // XXX: unsafe map access from multiple go routines whv.idToTxn[whtxn.Id] = whtxn // XXX: use return value to delete from map so we don't leak memory whv.HttpRequests.Add(whtxn) } else { rawResp, err := httputil.DumpResponse(htxn.Resp.Response, true) if err != nil { whv.Error("Failed to dump response: %v", err) continue } txn := htxn.UserCtx.(*SerializedTxn) body := makeBody(htxn.Resp.Header, htxn.Resp.BodyBytes) txn.Duration = htxn.Duration.Nanoseconds() txn.Resp = SerializedResponse{ Status: htxn.Resp.Status, Raw: base64.StdEncoding.EncodeToString(rawResp), Header: htxn.Resp.Header, Body: body, Binary: !utf8.Valid(rawResp), } payload, err := json.Marshal(txn) if err != nil { whv.Error("Failed to serialized txn payload for websocket: %v", err) } whv.webview.wsMessages.In() <- payload } } } func (whv *WebHttpView) register() { http.HandleFunc("/http/in/replay", func(w http.ResponseWriter, r *http.Request) { defer func() { if r := recover(); r != nil { err := util.MakePanicTrace(r) whv.Error("Replay failed: %v", err) http.Error(w, err, 500) } }() r.ParseForm() txnid := r.Form.Get("txnid") if txn, ok := whv.idToTxn[txnid]; ok { reqBytes, err := base64.StdEncoding.DecodeString(txn.Req.Raw) if err != nil { panic(err) } whv.ctl.PlayRequest(txn.ConnCtx.Tunnel, reqBytes) w.Write([]byte(http.StatusText(200))) } else { http.Error(w, http.StatusText(400), 400) } }) http.HandleFunc("/http/in", func(w http.ResponseWriter, r *http.Request) { defer func() { if r := recover(); r != nil { err := util.MakePanicTrace(r) whv.Error("HTTP web view failed: %v", err) http.Error(w, err, 500) } }() pageTmpl, err := assets.ReadAsset("assets/client/page.html") if err != nil { panic(err) } tmpl := template.Must(template.New("page.html").Delims("{%", "%}").Parse(string(pageTmpl))) payloadData := SerializedPayload{ Txns: whv.HttpRequests.Slice(), UiState: SerializedUiState{Tunnels: whv.ctl.State().GetTunnels()}, } payload, err := json.Marshal(payloadData) if err != nil { panic(err) } // write the response if err := tmpl.Execute(w, string(payload)); err != nil { panic(err) } }) } func (whv *WebHttpView) Shutdown() { } ngrok-1.6+dfsg.orig/src/ngrok/client/views/web/view.go 0000644 0000000 0000000 00000003413 12232501726 021455 0 ustar root root // interative web user interface package web import ( "github.com/garyburd/go-websocket/websocket" "net/http" "ngrok/client/assets" "ngrok/client/mvc" "ngrok/log" "ngrok/proto" "ngrok/util" "path" ) type WebView struct { log.Logger ctl mvc.Controller // messages sent over this broadcast are sent too all websocket connections wsMessages *util.Broadcast } func NewWebView(ctl mvc.Controller, addr string) *WebView { wv := &WebView{ Logger: log.NewPrefixLogger("view", "web"), wsMessages: util.NewBroadcast(), ctl: ctl, } // for now, always redirect to the http view http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, "/http/in", 302) }) // handle web socket connections http.HandleFunc("/_ws", func(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r.Header, nil, 1024, 1024) if err != nil { http.Error(w, "Failed websocket upgrade", 400) wv.Warn("Failed websocket upgrade: %v", err) return } msgs := wv.wsMessages.Reg() defer wv.wsMessages.UnReg(msgs) for m := range msgs { err := conn.WriteMessage(websocket.OpText, m.([]byte)) if err != nil { // connection is closed break } } }) // serve static assets http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) { buf, err := assets.ReadAsset(path.Join("assets", "client", r.URL.Path[1:])) if err != nil { wv.Warn("Error serving static file: %s", err.Error()) http.NotFound(w, r) return } w.Write(buf) }) wv.Info("Serving web interface on %s", addr) wv.ctl.Go(func() { http.ListenAndServe(addr, nil) }) return wv } func (wv *WebView) NewHttpView(proto *proto.Http) *WebHttpView { return newWebHttpView(wv.ctl, wv, proto) } func (wv *WebView) Shutdown() { } ngrok-1.6+dfsg.orig/src/ngrok/client/release.go 0000644 0000000 0000000 00000000147 12232501726 020212 0 ustar root root // +build release package client var ( rootCrtPaths = []string{"assets/client/tls/ngrokroot.crt"} ) ngrok-1.6+dfsg.orig/src/ngrok/client/debug.go 0000644 0000000 0000000 00000000214 12232501726 017653 0 ustar root root // +build !release package client var ( rootCrtPaths = []string{"assets/client/tls/ngrokroot.crt", "assets/client/tls/snakeoilca.crt"} ) ngrok-1.6+dfsg.orig/src/ngrok/client/controller.go 0000644 0000000 0000000 00000007073 12232501726 020762 0 ustar root root package client import ( "fmt" "ngrok/client/mvc" "ngrok/client/views/term" "ngrok/client/views/web" "ngrok/log" "ngrok/proto" "ngrok/util" "sync" ) type command interface{} type cmdQuit struct { // display this message after quit message string } type cmdPlayRequest struct { // the tunnel to play this request over tunnel mvc.Tunnel // the bytes of the request to issue payload []byte } // The MVC Controller type Controller struct { // Controller logger log.Logger // the model sends updates through this broadcast channel updates *util.Broadcast // the model model mvc.Model // the views views []mvc.View // interal structure to issue commands to the controller cmds chan command // internal structure to synchronize access to State object state chan mvc.State // options config *Configuration } // public interface func NewController() *Controller { ctl := &Controller{ Logger: log.NewPrefixLogger("controller"), updates: util.NewBroadcast(), cmds: make(chan command), views: make([]mvc.View, 0), state: make(chan mvc.State), } return ctl } func (ctl *Controller) State() mvc.State { return <-ctl.state } func (ctl *Controller) Update(state mvc.State) { ctl.updates.In() <- state } func (ctl *Controller) Updates() *util.Broadcast { return ctl.updates } func (ctl *Controller) Shutdown(message string) { ctl.cmds <- cmdQuit{message: message} } func (ctl *Controller) PlayRequest(tunnel mvc.Tunnel, payload []byte) { ctl.cmds <- cmdPlayRequest{tunnel: tunnel, payload: payload} } func (ctl *Controller) Go(fn func()) { go func() { defer func() { if r := recover(); r != nil { err := util.MakePanicTrace(r) ctl.Error(err) ctl.Shutdown(err) } }() fn() }() } // private functions func (ctl *Controller) doShutdown() { ctl.Info("Shutting down") var wg sync.WaitGroup // wait for all of the views, plus the model wg.Add(len(ctl.views) + 1) for _, v := range ctl.views { vClosure := v ctl.Go(func() { vClosure.Shutdown() wg.Done() }) } ctl.Go(func() { ctl.model.Shutdown() wg.Done() }) wg.Wait() } func (ctl *Controller) addView(v mvc.View) { ctl.views = append(ctl.views, v) } func (ctl *Controller) GetWebInspectAddr() string { return ctl.config.InspectAddr } func (ctl *Controller) Run(config *Configuration) { // Save the configuration ctl.config = config // init the model model := newClientModel(config, ctl) ctl.model = model var state mvc.State = model // init web ui var webView *web.WebView if config.InspectAddr != "disabled" { webView = web.NewWebView(ctl, config.InspectAddr) ctl.addView(webView) } // init term ui var termView *term.TermView if config.LogTo != "stdout" { termView = term.NewTermView(ctl) ctl.addView(termView) } for _, protocol := range model.GetProtocols() { switch p := protocol.(type) { case *proto.Http: if termView != nil { ctl.addView(termView.NewHttpView(p)) } if webView != nil { ctl.addView(webView.NewHttpView(p)) } default: } } ctl.Go(func() { autoUpdate(state, config.AuthToken) }) ctl.Go(ctl.model.Run) updates := ctl.updates.Reg() defer ctl.updates.UnReg(updates) done := make(chan int) for { select { case obj := <-ctl.cmds: switch cmd := obj.(type) { case cmdQuit: msg := cmd.message go func() { ctl.doShutdown() fmt.Println(msg) done <- 1 }() case cmdPlayRequest: ctl.Go(func() { ctl.model.PlayRequest(cmd.tunnel, cmd.payload) }) } case obj := <-updates: state = obj.(mvc.State) case ctl.state <- state: case <-done: return } } } ngrok-1.6+dfsg.orig/src/ngrok/client/tls.go 0000644 0000000 0000000 00000001205 12232501726 017370 0 ustar root root package client import ( "crypto/tls" "crypto/x509" "encoding/pem" "fmt" "ngrok/client/assets" ) func LoadTLSConfig(rootCertPaths []string) (*tls.Config, error) { pool := x509.NewCertPool() for _, certPath := range rootCertPaths { rootCrt, err := assets.ReadAsset(certPath) if err != nil { return nil, err } pemBlock, _ := pem.Decode(rootCrt) if pemBlock == nil { return nil, fmt.Errorf("Bad PEM data") } certs, err := x509.ParseCertificates(pemBlock.Bytes) if err != nil { return nil, err } pool.AddCert(certs[0]) } return &tls.Config{ RootCAs: pool, ServerName: "ngrokd.ngrok.com", }, nil } ngrok-1.6+dfsg.orig/src/ngrok/version/ 0000755 0000000 0000000 00000000000 12232501726 016450 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/version/version.go 0000644 0000000 0000000 00000000470 12232501726 020465 0 ustar root root package version import ( "fmt" ) const ( Proto = "2" Major = "1" Minor = "6" ) func MajorMinor() string { return fmt.Sprintf("%s.%s", Major, Minor) } func Full() string { return fmt.Sprintf("%s-%s.%s", Proto, Major, Minor) } func Compat(client string, server string) bool { return client == server } ngrok-1.6+dfsg.orig/src/ngrok/proto/ 0000755 0000000 0000000 00000000000 12232501726 016126 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/proto/tcp.go 0000644 0000000 0000000 00000000343 12232501726 017243 0 ustar root root package proto import ( "ngrok/conn" ) type Tcp struct{} func NewTcp() *Tcp { return new(Tcp) } func (h *Tcp) GetName() string { return "tcp" } func (h *Tcp) WrapConn(c conn.Conn, ctx interface{}) conn.Conn { return c } ngrok-1.6+dfsg.orig/src/ngrok/proto/http.go 0000644 0000000 0000000 00000006424 12232501726 017442 0 ustar root root package proto import ( "bytes" metrics "github.com/inconshreveable/go-metrics" "io" "io/ioutil" "net/http" "net/http/httputil" "ngrok/conn" "ngrok/util" "sync" "time" ) type HttpRequest struct { *http.Request BodyBytes []byte } type HttpResponse struct { *http.Response BodyBytes []byte } type HttpTxn struct { Req *HttpRequest Resp *HttpResponse Start time.Time Duration time.Duration UserCtx interface{} ConnUserCtx interface{} } type Http struct { Txns *util.Broadcast reqGauge metrics.Gauge reqMeter metrics.Meter reqTimer metrics.Timer } func NewHttp() *Http { return &Http{ Txns: util.NewBroadcast(), reqGauge: metrics.NewGauge(), reqMeter: metrics.NewMeter(), reqTimer: metrics.NewTimer(), } } func extractBody(r io.Reader) ([]byte, io.ReadCloser, error) { buf := new(bytes.Buffer) _, err := buf.ReadFrom(r) return buf.Bytes(), ioutil.NopCloser(buf), err } func (h *Http) GetName() string { return "http" } func (h *Http) WrapConn(c conn.Conn, ctx interface{}) conn.Conn { tee := conn.NewTee(c) lastTxn := make(chan *HttpTxn) go h.readRequests(tee, lastTxn, ctx) go h.readResponses(tee, lastTxn) return tee } func (h *Http) readRequests(tee *conn.Tee, lastTxn chan *HttpTxn, connCtx interface{}) { defer close(lastTxn) for { req, err := http.ReadRequest(tee.WriteBuffer()) if err != nil { // no more requests to be read, we're done break } // make sure we read the body of the request so that // we don't block the writer _, err = httputil.DumpRequest(req, true) h.reqMeter.Mark(1) if err != nil { tee.Warn("Failed to extract request body: %v", err) } // golang's ReadRequest/DumpRequestOut is broken. Fix up the request so it works later req.URL.Scheme = "http" req.URL.Host = req.Host txn := &HttpTxn{Start: time.Now(), ConnUserCtx: connCtx} txn.Req = &HttpRequest{Request: req} txn.Req.BodyBytes, txn.Req.Body, err = extractBody(req.Body) lastTxn <- txn h.Txns.In() <- txn } } func (h *Http) readResponses(tee *conn.Tee, lastTxn chan *HttpTxn) { for txn := range lastTxn { resp, err := http.ReadResponse(tee.ReadBuffer(), txn.Req.Request) txn.Duration = time.Since(txn.Start) h.reqTimer.Update(txn.Duration) if err != nil { tee.Warn("Error reading response from server: %v", err) // no more responses to be read, we're done break } // make sure we read the body of the response so that // we don't block the reader _, _ = httputil.DumpResponse(resp, true) txn.Resp = &HttpResponse{Response: resp} txn.Resp.BodyBytes, txn.Resp.Body, err = extractBody(resp.Body) if err != nil { tee.Warn("Failed to extract response body: %v", err) } h.Txns.In() <- txn // XXX: remove web socket shim in favor of a real websocket protocol analyzer if txn.Req.Header.Get("Upgrade") == "websocket" { tee.Info("Upgrading to websocket") var wg sync.WaitGroup // shim for websockets // in order for websockets to work, we need to continue reading all of the // the bytes in the analyzer so that the joined connections will continue // sending bytes to each other wg.Add(2) go func() { ioutil.ReadAll(tee.WriteBuffer()) wg.Done() }() go func() { ioutil.ReadAll(tee.ReadBuffer()) wg.Done() }() wg.Wait() break } } } ngrok-1.6+dfsg.orig/src/ngrok/proto/interface.go 0000644 0000000 0000000 00000000203 12232501726 020410 0 ustar root root package proto import ( "ngrok/conn" ) type Protocol interface { GetName() string WrapConn(conn.Conn, interface{}) conn.Conn } ngrok-1.6+dfsg.orig/src/ngrok/util/ 0000755 0000000 0000000 00000000000 12232501726 015740 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/util/errors.go 0000644 0000000 0000000 00000001244 12232501726 017604 0 ustar root root package util import ( "fmt" "runtime" ) const crashMessage = `panic: %v %s Oh noes! ngrok crashed! Please submit the stack trace and any relevant information to: github.com/inconshreveable/ngrok/issues` func MakePanicTrace(err interface{}) string { stackBuf := make([]byte, 4096) n := runtime.Stack(stackBuf, false) return fmt.Sprintf(crashMessage, err, stackBuf[:n]) } // Runs the given function and converts any panic encountered while doing so // into an error. Useful for sending to channels that will close func PanicToError(fn func()) (err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("Panic: %v", r) } }() fn() return } ngrok-1.6+dfsg.orig/src/ngrok/util/broadcast.go 0000644 0000000 0000000 00000002314 12232501726 020231 0 ustar root root package util type Broadcast struct { listeners []chan interface{} reg chan (chan interface{}) unreg chan (chan interface{}) in chan interface{} } func NewBroadcast() *Broadcast { b := &Broadcast{ listeners: make([]chan interface{}, 0), reg: make(chan (chan interface{})), unreg: make(chan (chan interface{})), in: make(chan interface{}), } go func() { for { select { case l := <-b.unreg: // remove L from b.listeners // this operation is slow: O(n) but not used frequently // unlike iterating over listeners oldListeners := b.listeners b.listeners = make([]chan interface{}, 0, len(oldListeners)) for _, oldL := range oldListeners { if l != oldL { b.listeners = append(b.listeners, oldL) } } case l := <-b.reg: b.listeners = append(b.listeners, l) case item := <-b.in: for _, l := range b.listeners { l <- item } } } }() return b } func (b *Broadcast) In() chan interface{} { return b.in } func (b *Broadcast) Reg() chan interface{} { listener := make(chan interface{}) b.reg <- listener return listener } func (b *Broadcast) UnReg(listener chan interface{}) { b.unreg <- listener } ngrok-1.6+dfsg.orig/src/ngrok/util/id.go 0000644 0000000 0000000 00000001745 12232501726 016672 0 ustar root root package util import ( "crypto/rand" "encoding/binary" "fmt" mrand "math/rand" ) func RandomSeed() (seed int64, err error) { err = binary.Read(rand.Reader, binary.LittleEndian, &seed) return } // creates a random identifier of the specified length func RandId(idlen int) string { b := make([]byte, idlen) var randVal uint32 for i := 0; i < idlen; i++ { byteIdx := i % 4 if byteIdx == 0 { randVal = mrand.Uint32() } b[i] = byte((randVal >> (8 * uint(byteIdx))) & 0xFF) } return fmt.Sprintf("%x", b) } // like RandId, but uses a crypto/rand for secure random identifiers func SecureRandId(idlen int) (id string, err error) { b := make([]byte, idlen) n, err := rand.Read(b) if n != idlen { err = fmt.Errorf("Only generated %d random bytes, %d requested", n, idlen) return } if err != nil { return } id = fmt.Sprintf("%x", b) return } func SecureRandIdOrPanic(idlen int) string { id, err := SecureRandId(idlen) if err != nil { panic(err) } return id } ngrok-1.6+dfsg.orig/src/ngrok/util/ring.go 0000644 0000000 0000000 00000001221 12232501726 017222 0 ustar root root package util import ( "container/list" "sync" ) type Ring struct { sync.Mutex *list.List capacity int } func NewRing(capacity int) *Ring { return &Ring{capacity: capacity, List: list.New()} } func (r *Ring) Add(item interface{}) interface{} { r.Lock() defer r.Unlock() // add new item r.PushFront(item) // remove old item if at capacity var old interface{} if r.Len() >= r.capacity { old = r.Remove(r.Back()) } return old } func (r *Ring) Slice() []interface{} { r.Lock() defer r.Unlock() i := 0 items := make([]interface{}, r.Len()) for e := r.Front(); e != nil; e = e.Next() { items[i] = e.Value i++ } return items } ngrok-1.6+dfsg.orig/src/ngrok/util/shutdown.go 0000644 0000000 0000000 00000001244 12232501726 020143 0 ustar root root package util import ( "sync" ) // A small utility class for managing controlled shutdowns type Shutdown struct { sync.Mutex inProgress bool begin chan int // closed when the shutdown begins complete chan int // closed when the shutdown completes } func NewShutdown() *Shutdown { return &Shutdown{ begin: make(chan int), complete: make(chan int), } } func (s *Shutdown) Begin() { s.Lock() defer s.Unlock() if s.inProgress == true { return } else { s.inProgress = true close(s.begin) } } func (s *Shutdown) WaitBegin() { <-s.begin } func (s *Shutdown) Complete() { close(s.complete) } func (s *Shutdown) WaitComplete() { <-s.complete } ngrok-1.6+dfsg.orig/src/ngrok/msg/ 0000755 0000000 0000000 00000000000 12232501726 015551 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/msg/msg.go 0000644 0000000 0000000 00000006723 12232501726 016676 0 ustar root root package msg import ( "encoding/json" "reflect" ) var TypeMap map[string]reflect.Type func init() { TypeMap = make(map[string]reflect.Type) t := func(obj interface{}) reflect.Type { return reflect.TypeOf(obj).Elem() } TypeMap["Auth"] = t((*Auth)(nil)) TypeMap["AuthResp"] = t((*AuthResp)(nil)) TypeMap["ReqTunnel"] = t((*ReqTunnel)(nil)) TypeMap["NewTunnel"] = t((*NewTunnel)(nil)) TypeMap["RegProxy"] = t((*RegProxy)(nil)) TypeMap["ReqProxy"] = t((*ReqProxy)(nil)) TypeMap["StartProxy"] = t((*StartProxy)(nil)) TypeMap["Ping"] = t((*Ping)(nil)) TypeMap["Pong"] = t((*Pong)(nil)) } type Message interface{} type Envelope struct { Type string Payload json.RawMessage } // When a client opens a new control channel to the server // it must start by sending an Auth message. type Auth struct { Version string // protocol version MmVersion string // major/minor software version (informational only) User string Password string OS string Arch string ClientId string // empty for new sessions } // A server responds to an Auth message with an // AuthResp message over the control channel. // // If Error is not the empty string // the server has indicated it will not accept // the new session and will close the connection. // // The server response includes a unique ClientId // that is used to associate and authenticate future // proxy connections via the same field in RegProxy messages. type AuthResp struct { Version string MmVersion string ClientId string Error string } // A client sends this message to the server over the control channel // to request a new tunnel be opened on the client's behalf. // ReqId is a random number set by the client that it can pull // from future NewTunnel's to correlate then to the requesting ReqTunnel. type ReqTunnel struct { ReqId string Protocol string // http only Hostname string Subdomain string HttpAuth string // tcp only RemotePort uint16 } // When the server opens a new tunnel on behalf of // a client, it sends a NewTunnel message to notify the client. // ReqId is the ReqId from the corresponding ReqTunnel message. // // A client may receive *multiple* NewTunnel messages from a single // ReqTunnel. (ex. A client opens an https tunnel and the server // chooses to open an http tunnel of the same name as well) type NewTunnel struct { ReqId string Url string Protocol string Error string } // When the server wants to initiate a new tunneled connection, it sends // this message over the control channel to the client. When a client receives // this message, it must initiate a new proxy connection to the server. type ReqProxy struct { } // After a client receives a ReqProxy message, it opens a new // connection to the server and sends a RegProxy message. type RegProxy struct { ClientId string } // This message is sent by the server to the client over a *proxy* connection before it // begins to send the bytes of the proxied request. type StartProxy struct { Url string // URL of the tunnel this connection connection is being proxied for ClientAddr string // Network address of the client initiating the connection to the tunnel } // A client or server may send this message periodically over // the control channel to request that the remote side acknowledge // its connection is still alive. The remote side must respond with a Pong. type Ping struct { } // Sent by a client or server over the control channel to indicate // it received a Ping. type Pong struct { } ngrok-1.6+dfsg.orig/src/ngrok/msg/pack.go 0000644 0000000 0000000 00000001577 12232501726 017030 0 ustar root root package msg import ( "encoding/json" "errors" "fmt" "reflect" ) func unpack(buffer []byte, msgIn Message) (msg Message, err error) { var env Envelope if err = json.Unmarshal(buffer, &env); err != nil { return } if msgIn == nil { t, ok := TypeMap[env.Type] if !ok { err = errors.New(fmt.Sprintf("Unsupposted message type %s", env.Type)) return } // guess type msg = reflect.New(t).Interface().(Message) } else { msg = msgIn } err = json.Unmarshal(env.Payload, &msg) return } func UnpackInto(buffer []byte, msg Message) (err error) { _, err = unpack(buffer, msg) return } func Unpack(buffer []byte) (msg Message, err error) { return unpack(buffer, nil) } func Pack(payload interface{}) ([]byte, error) { return json.Marshal(struct { Type string Payload interface{} }{ Type: reflect.TypeOf(payload).Elem().Name(), Payload: payload, }) } ngrok-1.6+dfsg.orig/src/ngrok/msg/conn.go 0000644 0000000 0000000 00000002243 12232501726 017036 0 ustar root root package msg import ( "encoding/binary" "errors" "fmt" "ngrok/conn" ) func readMsgShared(c conn.Conn) (buffer []byte, err error) { c.Debug("Waiting to read message") var sz int64 err = binary.Read(c, binary.LittleEndian, &sz) if err != nil { return } c.Debug("Reading message with length: %d", sz) buffer = make([]byte, sz) n, err := c.Read(buffer) c.Debug("Read message %s", buffer) if err != nil { return } if int64(n) != sz { err = errors.New(fmt.Sprintf("Expected to read %d bytes, but only read %d", sz, n)) return } return } func ReadMsg(c conn.Conn) (msg Message, err error) { buffer, err := readMsgShared(c) if err != nil { return } return Unpack(buffer) } func ReadMsgInto(c conn.Conn, msg Message) (err error) { buffer, err := readMsgShared(c) if err != nil { return } return UnpackInto(buffer, msg) } func WriteMsg(c conn.Conn, msg interface{}) (err error) { buffer, err := Pack(msg) if err != nil { return } c.Debug("Writing message: %s", string(buffer)) err = binary.Write(c, binary.LittleEndian, int64(len(buffer))) if err != nil { return } if _, err = c.Write(buffer); err != nil { return } return nil } ngrok-1.6+dfsg.orig/src/ngrok/main/ 0000755 0000000 0000000 00000000000 12232501726 015707 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/main/ngrok/ 0000755 0000000 0000000 00000000000 12232501726 017027 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/main/ngrok/ngrok.go 0000644 0000000 0000000 00000000111 12232501726 020467 0 ustar root root package main import ( "ngrok/client" ) func main() { client.Main() } ngrok-1.6+dfsg.orig/src/ngrok/main/ngrokd/ 0000755 0000000 0000000 00000000000 12232501726 017173 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/main/ngrokd/ngrokd.go 0000644 0000000 0000000 00000000111 12232501726 020777 0 ustar root root package main import ( "ngrok/server" ) func main() { server.Main() } ngrok-1.6+dfsg.orig/src/ngrok/log/ 0000755 0000000 0000000 00000000000 12232501726 015544 5 ustar root root ngrok-1.6+dfsg.orig/src/ngrok/log/logger.go 0000644 0000000 0000000 00000003730 12232501726 017355 0 ustar root root package log import ( log "code.google.com/p/log4go" "fmt" ) var root log.Logger = make(log.Logger) func LogTo(target string) { var writer log.LogWriter = nil switch target { case "stdout": writer = log.NewConsoleLogWriter() case "none": // no logging default: writer = log.NewFileLogWriter(target, true) } if writer != nil { root.AddFilter("log", log.DEBUG, writer) } } type Logger interface { AddLogPrefix(string) ClearLogPrefixes() Debug(string, ...interface{}) Info(string, ...interface{}) Warn(string, ...interface{}) error Error(string, ...interface{}) error } type PrefixLogger struct { *log.Logger prefix string } func NewPrefixLogger(prefixes ...string) Logger { logger := &PrefixLogger{Logger: &root} for _, p := range prefixes { logger.AddLogPrefix(p) } return logger } func (pl *PrefixLogger) pfx(fmtstr string) interface{} { return fmt.Sprintf("%s %s", pl.prefix, fmtstr) } func (pl *PrefixLogger) Debug(arg0 string, args ...interface{}) { pl.Logger.Debug(pl.pfx(arg0), args...) } func (pl *PrefixLogger) Info(arg0 string, args ...interface{}) { pl.Logger.Info(pl.pfx(arg0), args...) } func (pl *PrefixLogger) Warn(arg0 string, args ...interface{}) error { return pl.Logger.Warn(pl.pfx(arg0), args...) } func (pl *PrefixLogger) Error(arg0 string, args ...interface{}) error { return pl.Logger.Error(pl.pfx(arg0), args...) } func (pl *PrefixLogger) AddLogPrefix(prefix string) { if len(pl.prefix) > 0 { pl.prefix += " " } pl.prefix += "[" + prefix + "]" } func (pl *PrefixLogger) ClearLogPrefixes() { pl.prefix = "" } // we should never really use these . . . always prefer logging through a prefix logger func Debug(arg0 string, args ...interface{}) { root.Debug(arg0, args...) } func Info(arg0 string, args ...interface{}) { root.Info(arg0, args...) } func Warn(arg0 string, args ...interface{}) error { return root.Warn(arg0, args...) } func Error(arg0 string, args ...interface{}) error { return root.Error(arg0, args...) } ngrok-1.6+dfsg.orig/.gitignore 0000644 0000000 0000000 00000000253 12232501726 015044 0 ustar root root *.swp bin/ pkg/ src/code.google.com src/github.com src/bitbucket.org src/launchpad.net src/ngrok/client/assets/assets_release.go src/ngrok/server/assets/assets_release.go ngrok-1.6+dfsg.orig/LICENSE 0000644 0000000 0000000 00000001047 12232501726 014063 0 ustar root root Copyright 2013 Alan Shreve Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ngrok-1.6+dfsg.orig/README.md 0000644 0000000 0000000 00000003363 12232501726 014340 0 ustar root root # ngrok - Introspected tunnels to localhost ([homepage](https://ngrok.com)) ### "I want to securely expose a web server to the internet and capture all traffic for detailed inspection and replay"  ## What is ngrok? ngrok is a reverse proxy that creates a secure tunnel between from a public endpoint to a locally running web service. ngrok captures and analyzes all traffic over the tunnel for later inspection and replay. ## What can I do with ngrok? - Expose any http service behind a NAT or firewall to the internet on a subdomain of ngrok.com - Expose any tcp service behind a NAT or firewall to the internet on a random port of ngrok.com - Inspect all http requests/resposes that are transmitted over the tunnel - Replay any request that was transmitted over the tunnel ## What is ngrok useful for? - Temporarily sharing a website that is only running on your development machine - Demoing an app at a hackathon without deploying - Developing any services which consume webhooks (HTTP callbacks) by allowing you to replay those requests - Debugging and understanding any web service by inspecting the HTTP traffic - Running networked services on machines that are firewalled off from the internet ## Downloading and installing ngrok ngrok has _no_ runtime dependencies. Just download a single binary for your platform and run it. Some premium features are only available by creating an account on ngrok.com. If you need them, [create an account on ngrok.com](https://ngrok.com/signup). - [Linux](https://dl.ngrok.com/linux_386/ngrok.zip) - [Mac OSX](https://dl.ngrok.com/darwin_386/ngrok.zip) - [Windows](https://dl.ngrok.com/windows_386/ngrok.zip) ## Developing on ngrok [ngrok developer's guide](docs/DEVELOPMENT.md) ngrok-1.6+dfsg.orig/Makefile 0000644 0000000 0000000 00000001732 12232501726 014517 0 ustar root root .PHONY: default server client deps fmt clean all release-client release-server release-all client-assets server-assets export GOPATH:=$(shell pwd) default: all deps: go get -tags '$(BUILDTAGS)' -d -v ngrok/... server: deps go install -tags '$(BUILDTAGS)' ngrok/main/ngrokd fmt: go fmt ngrok/... client: deps go install -tags '$(BUILDTAGS)' ngrok/main/ngrok client-assets: go get github.com/inconshreveable/go-bindata GOOS="" GOARCH="" go install github.com/inconshreveable/go-bindata bin/go-bindata -o src/ngrok/client/assets assets/client server-assets: go get github.com/inconshreveable/go-bindata GOOS="" GOARCH="" go install github.com/inconshreveable/go-bindata bin/go-bindata -o src/ngrok/server/assets assets/server release-client: BUILDTAGS=release release-client: client-assets client release-server: BUILDTAGS=release release-server: server-assets server release-all: release-client release-server all: fmt client server clean: go clean -i -r ngrok/...